from typing import Annotated, List, Optional
from uuid import UUID

from fastapi import APIRouter, HTTPException, Query, status

from src.auth.service import CurrentUser
from src.database.core import DbSession
from src.database.service import CommonParameters
from src.models import StandardResponse

from .schema import (
    PlantFSTransactionDataCreate,
    PlantFSTransactionDataImport,
    PlantFSTransactionDataPagination,

    PlantFSTransactionDataRead,
    PlantFSTransactionDataUpdate,
    PlantFSChartData,
    ListQueryParams,
)
from .service import create, delete, get, get_all, update, update_fs_charts_from_matrix, get_charts

from typing import List

router = APIRouter()


@router.get("", response_model=StandardResponse[PlantFSTransactionDataPagination])
async def list_fs_transactions(
	db_session: DbSession,
	common: CommonParameters,
	params: Annotated[ListQueryParams, Query()],
):
	"""Return paginated financial statement transaction data."""

	records = await get_all(
		db_session=db_session,
		items_per_page=params.items_per_page,
		search=params.search,
		common=common,
	)

	return StandardResponse(
		data=records,
		message="Data retrieved successfully",
	)


@router.post(
    "/import/charts",
    response_model=StandardResponse[List[PlantFSTransactionDataRead]],
)
async def import_fs_charts(
    db_session: DbSession,
    payload: PlantFSTransactionDataImport,
    current_user: CurrentUser,
):
    updated, missing = await update_fs_charts_from_matrix(
        db_session=db_session,
        payload=payload,
        updated_by=current_user.user_id if current_user else None,
    )

    msg = "Data imported successfully."
    if missing:
        msg += f" Note: Years {missing} were not found."

    return StandardResponse(data=updated, message=msg)


@router.get("/charts", response_model=StandardResponse[PlantFSChartData])
async def get_chart_data(db_session: DbSession, common: CommonParameters):
    chart_data, bep_year, bep_total_lcc = await get_charts(
        db_session=db_session, common=common
    )
    if not chart_data:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="No chart data found.",
        )
    return StandardResponse(
        data={
            "items": chart_data,
            "bep_year": bep_year,
            "bep_total_lcc": bep_total_lcc,
        },
        message="Data retrieved successfully",
    )


@router.get(
	"/{fs_transaction_id}",
	response_model=StandardResponse[PlantFSTransactionDataRead],
)
async def retrieve_fs_transaction(
	db_session: DbSession,
	fs_transaction_id: UUID,
):
	record = await get(db_session=db_session, fs_transaction_id=str(fs_transaction_id))
	if not record:
		raise HTTPException(
			status_code=status.HTTP_404_NOT_FOUND,
			detail="A data with this id does not exist.",
		)

	return StandardResponse(data=record, message="Data retrieved successfully")


@router.post("", response_model=StandardResponse[PlantFSTransactionDataRead])
async def create_fs_transaction(
	db_session: DbSession,
	payload: PlantFSTransactionDataCreate,
	current_user: CurrentUser,
):
	record = await create(
		db_session=db_session,
		fs_transaction_in=payload,
		current_user=current_user,
	)

	return StandardResponse(data=record, message="Data created successfully")


@router.post(
	"/update/{fs_transaction_id}",
	response_model=StandardResponse[PlantFSTransactionDataRead],
)
async def update_fs_transaction(
	db_session: DbSession,
	fs_transaction_id: UUID,
	payload: PlantFSTransactionDataUpdate,
	current_user: CurrentUser,
):
	record = await get(db_session=db_session, fs_transaction_id=str(fs_transaction_id))
	if not record:
		raise HTTPException(
			status_code=status.HTTP_404_NOT_FOUND,
			detail="A data with this id does not exist.",
		)

	updated = await update(
		db_session=db_session,
		fs_transaction=record,
		fs_transaction_in=payload,
		current_user=current_user,
	)

	return StandardResponse(data=updated, message="Data updated successfully")


@router.post(
	"/delete/{fs_transaction_id}",
	response_model=StandardResponse[PlantFSTransactionDataRead],
)
async def delete_fs_transaction(
	db_session: DbSession,
	fs_transaction_id: UUID,
):
	record = await get(db_session=db_session, fs_transaction_id=str(fs_transaction_id))
	if not record:
		raise HTTPException(
			status_code=status.HTTP_404_NOT_FOUND,
			detail=[{"msg": "A data with this id does not exist."}],
		)

	await delete(db_session=db_session, fs_transaction_id=str(fs_transaction_id))

	return StandardResponse(data=record, message="Data deleted successfully")