import { type APIRoute } from "astro";
import validateAccessToken from "../../../lib/utils/validateAccessToken";
import { getUserResources, updateUserResources } from "../../../lib/utils/resourceManager";
import research from '../../../lib/data/research.json';
import { createOrUpgradeResearch, getUserByAccessToken, getUserResearch } from "../../../lib/db/users";
import type DBResource from "../../../types/DBResource";

export const POST: APIRoute = async({ request }) => {
    // validate access token
    const response = await validateAccessToken(request);
    if(response instanceof Response) return response;

    const user = await getUserByAccessToken(response);
    if(user === null) {
        return new Response(
            JSON.stringify({
                code: 401,
                message: "Unauthorized"
            }), { status: 401 }
        )
    }

    // check if research id is valid
    const researchId = (await request.json()).research;
    const researchData = research.filter((element: any) => element.id === researchId)[0];
    if(!researchId || !researchData) {
        return new Response(
            JSON.stringify({
                code: 400,
                message: "Bad Request",
                error: "Invalid research id"
            }), { status: 400 }
        )
    }
    
    // check requirements
    // buildings
    const buildings = user.buildings;
    researchData.requirements.buildings.forEach((buildingReq) => {
        if(buildings.filter((building) => building.id === buildingReq.id)[0].level < buildingReq.level) {
            return new Response(
                JSON.stringify({
                    code: 400,
                    message: "Bad Request",
                    error: `${buildingReq.id} level ${buildingReq.level} required`
                }), { status: 400 }
            )
        }
    });

    // research
    const playerResearch = await getUserResearch(user);
    researchData.requirements.research.forEach((researchReq) => {
        if(playerResearch.filter((research) => research.id === researchReq.id)[0].level < researchReq.level) {
            return new Response(
                JSON.stringify({
                    code: 400,
                    message: "Bad Request",
                    error: `${researchReq.id} level ${researchReq.level} required`
                }), { status: 400 }
            )
        }
    });

    // resources
    const resources = await getUserResources(user._id);
    const playerCurrentResearch = playerResearch.filter((element: any) => element.id === researchId)[0];
    const level = playerCurrentResearch ? playerCurrentResearch.level : 0;
    const newResources = structuredClone(resources);
    let hasEnoughResources = true;
    Object.entries(researchData.requirements.resources).forEach(([key, value]) => {
        const res = resources.filter((element: DBResource) => element.name === key)[0];
        const cost = playerCurrentResearch ? value * Math.pow(researchData.multiplier, level) : value;
        
        if(res.amount < cost) hasEnoughResources = false;
        else newResources.filter((element: DBResource) => element.name === key)[0].amount -= cost;
    });

    if(!hasEnoughResources) {
        return new Response(
            JSON.stringify({
                code: 400,
                message: "Bad Request",
                error: "Not enough resources"
            }), { status: 400 }
        )
    }

    await updateUserResources(user._id, newResources);
    await createOrUpgradeResearch(user.username, { id: researchId, level: level + 1 });

    return new Response(
        JSON.stringify({
            code: 200,
            message: "OK"
        }), { status: 200 }
    )
}