from decimal import Decimal

from sqlalchemy.orm import selectinload

from src.models import FinancialStatementLine, FinancialStatementValue, FinancialStatementMeta
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, update

from src.schemas import FileFslPatchSchema


class FinStatRepository:
    def __init__(self, session: AsyncSession):
        self.session = session

    #TODO
    async def get_metas_by_file_id(self, file_id):
        stmt = (
            select(FinancialStatementMeta)
            .where(FinancialStatementMeta.stored_file_id == file_id)
            .options(
                selectinload(FinancialStatementMeta.lines).selectinload(FinancialStatementLine.values)
            )
            .order_by(FinancialStatementMeta.statement_type)
        )
        result = await self.session.execute(stmt)
        return list(result.scalars().all())

    async def update_file_fsl(self, file_id, payload: FileFslPatchSchema):
        await self._mark_file_recognized(file_id)
        for t in payload.tables:
            if t.meta:
                meta_values = {}
                print(t.meta)
                for meta_item in t.meta:
                    if (meta_item.key == 'inn'):
                        meta_values['inn'] = meta_item.cell.value

                    elif (meta_item.key == 'units'):
                        meta_values['units'] = meta_item.cell.value

                    elif (meta_item.key == 'report_date'):
                        meta_values['report_date'] = meta_item.cell.value
                stmt = update(FinancialStatementMeta).where(FinancialStatementMeta.id == t.table_id).values(**meta_values).returning(FinancialStatementMeta)
                res = await self.session.execute(stmt)

            if t.cells:
                for c in t.cells:
                    line_id = c.line_id
                    if c.field is not None:
                        values = {c.field: c.cell.value}
                        stmt = update(FinancialStatementLine).where(FinancialStatementLine.id == line_id).values(**values)
                        await self.session.execute(stmt)
                    else:
                        value_id = c.value_id
                        raw = c.cell.value
                        values = {}
                        try:
                            amount = Decimal(raw.strip().replace(',', '.'))
                            values['amount'] = amount
                        except:
                            values['string_value'] = raw
                        stmt = update(FinancialStatementValue).where(FinancialStatementValue.id == value_id).values(**values)
                        await self.session.execute(stmt)

        return file_id

    async def _mark_file_recognized(self, file_id):
        meta_values = {
            'inn_verified': True,
            'units_verified': True,
            'report_date_verified': True
        }
        metas = await self.session.execute(update(FinancialStatementMeta)
                                          .where(FinancialStatementMeta.stored_file_id == file_id)
                                          .values(**meta_values)
                                          .returning(FinancialStatementMeta.id))

        lines = await self.session.execute(update(FinancialStatementLine)
                                           .where(FinancialStatementLine.meta_id.in_(metas.scalars().all()))
                                           .values(line_code_recognized=True, line_name_recognized=True)
                                           .returning(FinancialStatementLine.id))

        values = await self.session.execute(update(FinancialStatementValue)
                                           .where(FinancialStatementValue.line_id.in_(lines.scalars().all()))
                                           .values(is_recognized=True))