import { eq } from 'drizzle-orm';
import useDatabase from '~/composables/useDatabase';
import { characterAbilitiesTable, characterLevelingTable, characterModifiersTable, characterSpellsTable, characterTable, characterTrainingTable } from '~/db/schema';
import { CharacterValidation, type Ability, type MainStat } from '~/types/character';

export default defineEventHandler(async (e) => {
    const params = getRouterParam(e, "id");
    if(!params)
    {
        setResponseStatus(e, 400);
        return;
    }
    const id = parseInt(params, 10);

    const body = await readValidatedBody(e, CharacterValidation.safeParse);
    if(!body.success)
    {
        setResponseStatus(e, 400);
        return body.error.message;
    }

    const db = useDatabase();
    const old = db.select({ id: characterTable.id, owner: characterTable.owner }).from(characterTable).where(eq(characterTable.id, id)).get();
    
    if(!old)
    {
        setResponseStatus(e, 404);
        return;
    }

    const session = await getUserSession(e);
    if(!session.user || old.owner !== session.user.id || session.user.state !== 1)
    {
        setResponseStatus(e, 401);
        return;
    }
    
    db.transaction((tx) => {
        tx.update(characterTable).set({
            name: body.data.name,
            people: body.data.people!,
            level: body.data.level,
            aspect: body.data.aspect,
            notes: body.data.notes,
            health: body.data.health,
            mana: body.data.mana,
            visibility: body.data.visibility,
            thumbnail: body.data.thumbnail,
        }).where(eq(characterTable.id, id)).run();

        tx.delete(characterLevelingTable).where(eq(characterLevelingTable.character, id)).run();
        tx.delete(characterTrainingTable).where(eq(characterTrainingTable.character, id)).run();
        tx.delete(characterModifiersTable).where(eq(characterModifiersTable.character, id)).run();
        tx.delete(characterSpellsTable).where(eq(characterSpellsTable.character, id)).run();
        tx.delete(characterAbilitiesTable).where(eq(characterAbilitiesTable.character, id)).run();

        if(body.data.leveling.length > 0) tx.insert(characterLevelingTable).values(body.data.leveling.map(e => ({ character: id, level: e[0], choice: e[1] }))).run();

        const training = Object.entries(body.data.training).flatMap(e => e[1].map(_e => ({ character: id, stat: e[0] as MainStat, level: _e[0], choice: _e[1] })));
        if(training.length > 0) tx.insert(characterTrainingTable).values(training).run();

        const modifiers = Object.entries(body.data.modifiers).map((e) => ({ character: id, modifier: e[0] as MainStat, value: e[1] }));
        if(modifiers.length > 0) tx.insert(characterModifiersTable).values(modifiers).run();

        if(body.data.spells.length > 0) tx.insert(characterSpellsTable).values(body.data.spells.map(e => ({ character: id, value: e }))).run();

        const abilities = Object.entries(body.data.abilities).map(e => ({ character: id, ability: e[0] as Ability, value: e[1][0], max: e[1][1] }));
        if(abilities.length > 0) tx.insert(characterAbilitiesTable).values(abilities).run();
    });

    await useStorage('cache').removeItem(`nitro:functions:character:${id}.json`);

    setResponseStatus(e, 200);
    return;
});