from datetime import datetime, timedelta
from fastapi import APIRouter, Depends, Request
from fastapi.responses import RedirectResponse

from db.handlers.access import AccessLevelHandler
from db.handlers.categories import CategoryHandler
from db.handlers.orders import OrdersHandler
from utils import render, requestDict, logger
from .user import router as user
from .stocks import router as stocks
from .toolbox import router as toolbox
from .toolkit import router as toolkit
from .records import router as records
from .orders import router as orders


router = APIRouter()

router.include_router(user, prefix="/user", tags=["user"])
router.include_router(stocks, prefix="/stocks", tags=["stocks"])
router.include_router(toolbox, prefix="/toolbox", tags=["toolbox"])
router.include_router(toolkit, prefix="/toolkit", tags=["toolkit"])
router.include_router(records, prefix="/records", tags=["records"])
router.include_router(orders, prefix="/orders", tags=["orders"])


@router.get("/")
async def main_page(request: Request):
    cookies = request.cookies
    checkList = ["toolbox_user", "toolbox_access"]
    if all(key in cookies for key in checkList):
        return await render(request)
    else:
        for key in checkList:
            if key in cookies:
                deleteCookie = key
                break
        else:
            deleteCookie = None

        if deleteCookie:
            response = RedirectResponse(url="/user/login", status_code=302)
            response.set_cookie(deleteCookie, "", expires=0)
            return response
        else:
            return RedirectResponse(url="/user/login", status_code=302)


@router.post("/")
async def post_requests(
    request_data: dict = Depends(requestDict),
):
    from db.handlers.records import ServiceRecordsHandler, StocksRecordsHandler
    from db.handlers.toolbox import ToolboxHandler
    from db.handlers.toolkit import ToolkitHandler
    from db.handlers.user import UserHandler

    def getDates(data: dict):
        startDate = data.get("startDate")
        if isinstance(startDate, str):
            startDate = datetime.strptime(startDate, "%Y-%m-%d").date()
        if startDate is None:
            startDate = datetime.now().date() - timedelta(days=30)
        endDate = data.get("endDate")
        if isinstance(endDate, str):
            endDate = datetime.strptime(endDate, "%Y-%m-%d").date()
        if endDate is None:
            endDate = datetime.now().date()
        if startDate > endDate:
            startDate, endDate = endDate, startDate
        return startDate, endDate

    reqData = {
        "tab": request_data.get("body").get("tabId"),
    }
    if "cookiesData" in request_data.get("body"):
        if "userData" in request_data.get("body").get("cookiesData"):
            reqData["userData"] = (
                request_data.get("body").get("cookiesData").get("userData")
            )
        if "accessData" in request_data.get("body").get("cookiesData"):
            reqData["accessData"] = (
                request_data.get("body").get("cookiesData").get("accessData")
            )
    resultData = {"status": "error", "data": {}}
    logger.info(f"Получение данных для вкладки {reqData.get('tab')}")
    match reqData.get("tab"):
        case "toolbox":
            if reqData.get("accessData").get("view_all_toolboxes", False):
                toolbox = await ToolboxHandler.getAll()
            else:
                toolbox = await ToolboxHandler.getByOwner(
                    reqData.get("userData").get("id")
                )
            if toolbox:
                resultData["status"] = "ok"
                resultData["data"] = toolbox
        case "requests":
            canDesign = reqData.get("accessData").get(
                "refund_request_confirm", False
            ) or reqData.get("accessData").get("debit_request_confirm", False)
            userId = reqData.get("userData").get("id")
            requests = await StocksRecordsHandler.get(userId, canDesign)
            users = await UserHandler.getAll()
            toolboxes = await ToolboxHandler.getAll()
            toolkitsIds = set([request.get("toolkit_id") for request in requests])
            toolkits = await ToolkitHandler.getSeveral(list(toolkitsIds))
            if isinstance(requests, list):
                resultData["status"] = "ok"
                resultData["data"] = {
                    "requests": requests,
                    "users": users,
                    "toolboxes": toolboxes,
                    "toolkits": toolkits,
                }
        case "toolkits":
            toolkits = await ToolkitHandler.getAll()
            categories = await CategoryHandler.getAll()
            if toolkits and categories:
                resultData["status"] = "ok"
                resultData["data"] = {
                    "toolkits": toolkits,
                    "categories": categories,
                }
        case "jurnal_toolkits":
            startDate, endDate = getDates(request_data.get("body"))

            jurnal_toolkits = await StocksRecordsHandler.getLogs(startDate, endDate)
            if isinstance(jurnal_toolkits, list):
                if len(jurnal_toolkits) == 0:
                    resultData["status"] = "ok"
                    resultData["data"] = {
                        "requests": [],
                        "users": [],
                        "toolboxes": [],
                        "toolkits": [],
                        "startDate": startDate.strftime("%Y-%m-%d"),
                        "endDate": endDate.strftime("%Y-%m-%d"),
                    }
                else:
                    users = await UserHandler.getAll()
                    toolboxes = await ToolboxHandler.getAll()
                    toolkitsIds = set(
                        [request.get("toolkit_id") for request in jurnal_toolkits]
                    )
                    toolkits = await ToolkitHandler.getSeveral(list(toolkitsIds))
                    resultData["status"] = "ok"
                    resultData["data"] = {
                        "requests": jurnal_toolkits,
                        "users": users,
                        "toolboxes": toolboxes,
                        "toolkits": toolkits,
                        "startDate": startDate.strftime("%Y-%m-%d"),
                        "endDate": endDate.strftime("%Y-%m-%d"),
                    }
        case "jurnal_service":
            startDate, endDate = getDates(request_data.get("body"))

            jurnal_service = await ServiceRecordsHandler.getLogs(startDate, endDate)
            if isinstance(jurnal_service, list):
                if len(jurnal_service) == 0:
                    resultData["status"] = "ok"
                    resultData["data"] = {
                        "requests": [],
                        "users": [],
                        "categories": [],
                        "startDate": startDate.strftime("%Y-%m-%d"),
                        "endDate": endDate.strftime("%Y-%m-%d"),
                    }
                else:
                    users = await UserHandler.getAll()
                    categories = await CategoryHandler.getAll()
                    resultData["status"] = "ok"
                    resultData["data"] = {
                        "requests": jurnal_service,
                        "users": users,
                        "categories": categories,
                        "startDate": startDate.strftime("%Y-%m-%d"),
                        "endDate": endDate.strftime("%Y-%m-%d"),
                    }
        case "users":
            users = await UserHandler.getAll()
            if isinstance(users, list):
                if len(users) == 0:
                    resultData["status"] = "ok"
                    resultData["data"] = {
                        "users": [],
                        "accessLevels": [],
                    }
                for user in users:
                    user.pop("hashed_password")
                accessLevels = await AccessLevelHandler.getAll()
                resultData["status"] = "ok"
                resultData["data"] = {
                    "users": users,
                    "accessLevels": accessLevels,
                }
        case "orders":
            fullAccess = reqData["accessData"].get("view_all_toolboxes", False)
            startDate, endDate = getDates(request_data.get("body"))
            if fullAccess:
                result = await OrdersHandler.get_all(startDate, endDate)
                if "errorMessage" in result.keys():
                    resultData["message"] = result["errorMessage"]
                else:
                    resultData["status"] = "ok"
                    if "orders" in result.keys():
                        resultData["data"]["orders"] = result["orders"]
            else:
                userId = reqData.get("userData").get("id")
                result = await OrdersHandler.get_all_by_consumer(
                    userId, startDate, endDate
                )
                if "errorMessage" in result.keys():
                    resultData["message"] = result["errorMessage"]
                else:
                    resultData["status"] = "ok"
                    if "orders" in result.keys():
                        resultData["data"]["orders"] = result["orders"]
            if resultData["status"] == "ok":
                resultData["data"]["startDate"] = startDate.strftime("%Y-%m-%d")
                resultData["data"]["endDate"] = endDate.strftime("%Y-%m-%d")
                resultData["data"]["users"] = await UserHandler.getAll()
                resultData["data"]["fullAccess"] = fullAccess
        case _:
            pass
    return resultData