import logging
import requests
import json
import os
from datetime import datetime, timedelta
from asgiref.sync import sync_to_async
from hotels.models import Hotel, Reservation
from .base_plugin import BasePMSPlugin

class RealtyCalendarPMSPlugin(BasePMSPlugin):
    def __init__(self, hotel):
        super().__init__(hotel.pms)
        self.hotel = hotel

        if not self.hotel.pms:
            raise ValueError(f"Отель {self.hotel.name} не имеет связанной PMS конфигурации.")

        self.api_url = self.hotel.pms.url.rstrip("/")
        self.public_key = self.hotel.pms.public_key
        self.private_key = self.hotel.pms.private_key

        self.logger = logging.getLogger(self.__class__.__name__)
        handler_console = logging.StreamHandler()
        handler_file = logging.FileHandler('var/log/realtycalendar_pms_plugin.log')
        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
        handler_console.setFormatter(formatter)
        handler_file.setFormatter(formatter)
        self.logger.addHandler(handler_console)
        self.logger.addHandler(handler_file)
        self.logger.setLevel(logging.WARNING)

    def get_default_parser_settings(self):
        return {
            "field_mapping": {
                "check_in": "begin_date",
                "check_out": "end_date",
                "room_number": "apartment_id",
                "room_type_name": "notes",
                "status": "status",
            },
            "date_format": "%Y-%m-%d %H:%M:%S"
        }

    async def _fetch_data(self):
        headers = {"Accept": "application/json", "Content-Type": "application/json"}
        now = datetime.now()
        data = {
            "begin_date": (now - timedelta(days=7)).strftime("%Y-%m-%d"),
            "end_date": now.strftime("%Y-%m-%d"),
            "sign": self._generate_sign()
        }

        try:
            response = await sync_to_async(requests.post)(
                f"{self.api_url}/api/v1/bookings/{self.public_key}/",
                headers=headers, json=data
            )
            response.raise_for_status()
            response_data = response.json()
            return await self._process_data(response_data)
        except requests.exceptions.RequestException as e:
            self.logger.error(f"Ошибка API: {e}")
            return {"processed_intervals": 0, "processed_items": 0, "errors": [str(e)]}

    async def _process_data(self, data):
        processed_items = 0
        errors = []
        date_formats = ["%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S"]

        for item in data.get("bookings", []):
            try:
                checkin = self._parse_date(item['begin_date'], date_formats)
                checkout = self._parse_date(item['end_date'], date_formats)

                reservation, created = await sync_to_async(Reservation.objects.update_or_create)(
                    reservation_id=item['id'],
                    defaults={
                        'room_number': item['apartment_id'],
                        'room_type': item.get('notes', 'Описание отсутствует'),
                        'check_in': checkin,
                        'check_out': checkout,
                        'status': item['status'],
                        'hotel': self.hotel,
                    }
                )
                processed_items += 1
            except Exception as e:
                self.logger.error(f"Ошибка обработки записи: {e}")
                errors.append(str(e))

        return {"processed_intervals": 1, "processed_items": processed_items, "errors": errors}

    def _generate_sign(self):
        return hashlib.md5((self.public_key + self.private_key).encode("utf-8")).hexdigest()

    @staticmethod
    def _parse_date(date_str, formats):
        for fmt in formats:
            try:
                return datetime.strptime(date_str, fmt)
            except ValueError:
                continue
        raise ValueError(f"Дата '{date_str}' не соответствует ожидаемым форматам: {formats}")

    def validate_plugin(self):
        required_methods = ["fetch_data", "get_default_parser_settings", "_fetch_data"]
        for method in required_methods:
            if not hasattr(self, method):
                raise ValueError(f"Плагин {type(self).__name__} не реализует метод {method}.")
        self.logger.debug(f"Плагин {self.__class__.__name__} успешно прошел валидацию.")
        return True