from collections import defaultdict
from io import BytesIO
from typing import List

from fastapi import HTTPException
from number_to_string import get_string_by_number
from sqlalchemy import select
from sqlalchemy.orm import selectinload, joinedload
from starlette import status
from weasyprint import HTML, CSS

import backend.config
import constants
import models
from constants import MONTHS, ENV
from external.billing import BillingClient, CreateBillingRequestValue, CreateBillRequestSchema, CreateBillRequestItems, \
    BillStatusUpdateRequest, NotificationChannel, NotifyReceivedBillRequestSchema, DeleteBillRequestSchema, \
    ProductBillingDocumentPdf, ServiceBillingDocumentPdf
from models import DealBillRequest, Deal, DealProduct, DealService as DealServiceModel, DealProductService
from schemas.billing import *
from services.base import BaseService
from services.deal import DealService
from utils.list_utils import to_locale_number


class BillingService(BaseService):
    async def _process_update_details(
            self,
            request: BillStatusUpdateRequest
    ):
        billing_client = BillingClient(backend.config.BILLING_API_KEY)
        notify_received_request = NotifyReceivedBillRequestSchema(
            listener_transaction_id=request.listener_transaction_id,
            channel=NotificationChannel.PAYMENT_DETAILS,
            received=True
        )
        response = await billing_client.notify_received(notify_received_request)
        deal_bill_request = await self._get_deal_bill_by_id(request.listener_transaction_id)
        if not response.ok:
            return
        deal_bill_request.pdf_url = request.info.pdf_url
        deal_bill_request.invoice_number = request.info.invoice_number
        await self.session.commit()

    async def _process_update_verification(
            self,
            request: BillStatusUpdateRequest
    ):
        billing_client = BillingClient(backend.config.BILLING_API_KEY)
        notify_received_request = NotifyReceivedBillRequestSchema(
            listener_transaction_id=request.listener_transaction_id,
            channel=NotificationChannel.PAYMENT_VERIFICATION,
            received=True
        )
        response = await billing_client.notify_received(notify_received_request)
        if not response.ok:
            return
        deal_bill_request = await self._get_deal_bill_by_id(request.listener_transaction_id)
        if not deal_bill_request:
            return
        deal_bill_request.paid = request.info.payed
        await self.session.commit()

    async def process_update(
            self,
            request: BillStatusUpdateRequest
    ):
        if request.channel == NotificationChannel.PAYMENT_DETAILS:
            await self._process_update_details(request)
        elif request.channel == NotificationChannel.PAYMENT_VERIFICATION:
            await self._process_update_verification(request)

    async def create_deal_billing(self, user, request: CreateDealBillRequest) -> CreateDealBillResponse:
        try:
            deal_service = DealService(self.session)
            billing_client = BillingClient(backend.config.BILLING_API_KEY)

            basic_deal: Deal = await deal_service.get_by_id(user, request.deal_id, return_raw=True)
            deals = await deal_service.get_deals_grouped(basic_deal)

            billing_request_values: List[CreateBillingRequestValue] = []

            psq = defaultdict(lambda: defaultdict(lambda: 0))
            sq = defaultdict(lambda: 0)

            services_dict = {}
            products_dict = {}
            for deal in deals:
                for product in deal.products:
                    product: DealProduct
                    for service in product.services:
                        service: DealProductService
                        psq[product.product_id][service.service_id] += product.quantity
                        products_dict[product.product_id] = product.product
                        services_dict[service.service_id] = service.service

            for deal in deals:
                for service in deal.services:
                    service: models.DealService
                    services_dict[service.service_id] = service.service
                    sq[service.service_id] += service.quantity

            for product_id, services_ids in psq.items():
                product: models.Product = products_dict[product_id]
                for service_id in services_ids:
                    service = services_dict[service_id]
                    service: models.Service
                    quantity = psq[product_id][service_id]
                    billing_request_values.append(
                        CreateBillingRequestValue(
                            name=f'[{product.name}] - {service.name}',
                            price=service.price,
                            amount=quantity
                        )
                    )
            for service_id, quantity in sq.items():
                service: models.Service = services_dict[service_id]
                billing_request_values.append(
                    CreateBillingRequestValue(
                        name=f'{service.name}',
                        price=service.price,
                        amount=quantity
                    )
                )
            deal = basic_deal
            create_bill_request = CreateBillRequestSchema(
                listener_transaction_id=deal.id,
                payer_name=deal.client.name,
                payer_inn=deal.client.details.inn,
                payer_phone=deal.client.details.phone_number,
                items=CreateBillRequestItems(
                    values=billing_request_values
                )
            )
            create_bill_response = await billing_client.create(create_bill_request)
            if not create_bill_response.ok:
                return CreateDealBillResponse(ok=create_bill_response.ok, message='Ошибка!')
            deal_bill_request = DealBillRequest(
                deal_id=request.deal_id,
                created_at=datetime.datetime.now()
            )
            self.session.add(deal_bill_request)
            deal.is_locked = True
            await self.session.commit()
            return CreateDealBillResponse(ok=create_bill_response.ok, message='Заявка успешно создана!')
        except Exception as e:
            return CreateDealBillResponse(ok=False, message=str(e))

    async def _get_deal_bill_by_id(self, deal_id: int) -> Optional[DealBillRequest]:
        return await self.session.scalar(select(DealBillRequest).where(DealBillRequest.deal_id == deal_id))

    async def get_deal_bill_by_id(self, deal_id: int) -> GetDealBillById:
        deal_bill = await self._get_deal_bill_by_id(deal_id)
        if not deal_bill:
            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='Deal bill was not found')
        return GetDealBillById(deal_bill=DealBillRequestSchema.model_validate(deal_bill))

    async def cancel_deal_billing(self, user, request: CancelDealBillRequest) -> CancelDealBillResponse:
        try:
            deal_bill = await self._get_deal_bill_by_id(request.deal_id)
            if not deal_bill:
                return CancelDealBillResponse(ok=False, message='Заявка не найдена')
            billing_client = BillingClient(backend.config.BILLING_API_KEY)
            response = await billing_client.delete(DeleteBillRequestSchema(listener_transaction_id=request.deal_id))
            if not response.ok:
                return CancelDealBillResponse(ok=False, message='Ошибка')
            await self.session.delete(deal_bill)
            await self.session.commit()
            return CancelDealBillResponse(ok=True, message='Заявка успешно отозвана')
        except Exception as e:
            return CancelDealBillResponse(ok=False, message=str(e))

    async def _get_products_for_deal(self, deal: Deal) -> tuple[list, list, bool]:
        services: list[ServiceBillingDocumentPdf] = []
        products: list[ProductBillingDocumentPdf] = []
        is_size_needed: bool = False

        for product in deal.products:
            product_price = 0
            for service in product.services:
                services.append(
                    ServiceBillingDocumentPdf(
                        name=f'[{product.product.name}] - {service.service.name}',
                        price=service.price,
                        quantity=product.quantity
                    )
                )
                product_price += service.price
            is_size_needed = is_size_needed | bool(product.product.size)
            products.append(
                ProductBillingDocumentPdf(
                    article=product.product.article,
                    size=product.product.size if product.product.size else "",
                    price=product_price,
                    quantity=product.quantity,
                )
            )
        for service in deal.services:
            services.append(
                ServiceBillingDocumentPdf(
                    name=f'{service.service.name}',
                    price=service.price,
                    quantity=service.quantity
                )
            )

        return services, products, is_size_needed

    async def _create_billing_document_html(self, deal_id: int):
        deal: Deal | None = await self.session.scalar(
            select(Deal)
            .where(Deal.id == deal_id)
            .options(
                selectinload(Deal.products).selectinload(DealProduct.services),
                selectinload(Deal.services).selectinload(DealServiceModel.service),
                joinedload(Deal.shipping_warehouse),
                joinedload(Deal.client),
            )
        )

        if not deal:
            return ""

        (services, products, is_size_needed) = await self._get_products_for_deal(deal)

        deal_price = sum((service.price * service.quantity for service in services))
        deal_price_words = get_string_by_number(deal_price)[0:-10]
        deal_price = to_locale_number(deal_price)
        template = ENV.get_template("bill-of-payment.html")

        now = datetime.datetime.now()
        curr_date = f"{now.day} {MONTHS[now.month - 1]} {now.year} г."
        return template.render({
            "products": products,
            "services": services,
            "is_size_needed": is_size_needed,
            "deal_price": deal_price,
            "deal_price_words": deal_price_words,
            "deal": deal,
            "curr_date": curr_date
        })

    async def create_billing_document_pdf(self, deal_id) -> BytesIO:
        doc = await self._create_billing_document_html(deal_id)
        pdf_file = BytesIO()
        HTML(string=doc).write_pdf(pdf_file, stylesheets=[CSS(constants.APP_PATH + '/static/css/bill-of-payment.css')])

        return pdf_file