import { formatDate } from "./utils";
import { callNotifikace } from "./notifikace";
import { generateQr } from "./qr";
import getStorage from "./storage";
import { downloadPizzy, downloadSalaty } from "./chefie";
import { getClientData, getToday, initIfNeeded } from "./service";
import { Pizza, Salat, ClientData, PizzaDayState, PizzaSize, PizzaOrder, PizzaVariant, UdalostEnum, PendingQr } from "../../types/gen/types.gen";
import crypto from "crypto";

const storage = getStorage();
const PENDING_QR_PREFIX = 'pending_qr';

/**
 * Vrátí seznam dostupných pizz pro dnešní den.
 * Stáhne je, pokud je pro dnešní den nemá.
 */
export async function getPizzaList(): Promise<Pizza[] | undefined> {
    await initIfNeeded();
    let clientData = await getClientData(getToday());
    if (!clientData.pizzaList) {
        const mock = process.env.MOCK_DATA === 'true';
        clientData = await savePizzaList(await downloadPizzy(mock));
    }
    return Promise.resolve(clientData.pizzaList);
}

/**
 * Uloží seznam dostupných pizz pro dnešní den.
 *
 * @param pizzaList seznam dostupných pizz
 */
export async function savePizzaList(pizzaList: Pizza[]): Promise<ClientData> {
    await initIfNeeded();
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    clientData.pizzaList = pizzaList;
    clientData.pizzaListLastUpdate = formatDate(new Date());
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Vrátí seznam dostupných salátů pro dnešní den.
 * Stáhne je, pokud je pro dnešní den nemá.
 */
export async function getSalatList(): Promise<Salat[] | undefined> {
    await initIfNeeded();
    let clientData = await getClientData(getToday());
    if (!clientData.salatList) {
        const mock = process.env.MOCK_DATA === 'true';
        clientData = await saveSalatList(await downloadSalaty(mock));
    }
    return Promise.resolve(clientData.salatList);
}

/**
 * Uloží seznam dostupných salátů pro dnešní den.
 *
 * @param salatList seznam dostupných salátů
 */
export async function saveSalatList(salatList: Salat[]): Promise<ClientData> {
    await initIfNeeded();
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    clientData.salatList = salatList;
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Vytvoří pizza day pro aktuální den a vrátí data pro klienta.
 */
export async function createPizzaDay(creator: string): Promise<ClientData> {
    await initIfNeeded();
    const clientData = await getClientData(getToday());
    if (clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den již existuje");
    }
    // TODO berka rychlooprava, vyřešit lépe - stahovat jednou, na jediném místě!
    const [pizzaList, salatList] = await Promise.all([getPizzaList(), getSalatList()]);
    const data: ClientData = { pizzaDay: { state: PizzaDayState.CREATED, creator, orders: [] }, pizzaList, salatList, ...clientData };
    const today = formatDate(getToday());
    await storage.setData(today, data);
    callNotifikace({ input: { udalost: UdalostEnum.ZAHAJENA_PIZZA, user: creator } })
    return data;
}

/**
 * Smaže pizza day pro aktuální den.
 */
export async function deletePizzaDay(login: string): Promise<ClientData> {
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.creator !== login) {
        throw Error("Login uživatele se neshoduje se zakladatelem Pizza Day");
    }
    delete clientData.pizzaDay;
    const today = formatDate(getToday());
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Přidá objednávku pizzy uživateli.
 * 
 * @param login login uživatele
 * @param pizza zvolená pizza
 * @param size zvolená velikost pizzy
 */
export async function addPizzaOrder(login: string, pizza: Pizza, size: PizzaSize) {
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
    }
    let order: PizzaOrder | undefined = clientData.pizzaDay?.orders?.find(o => o.customer === login);
    if (!order) {
        order = {
            customer: login,
            pizzaList: [],
            totalPrice: 0,
            hasQr: false,
        }
        clientData.pizzaDay.orders ??= [];
        clientData.pizzaDay.orders.push(order);
    }
    const pizzaOrder: PizzaVariant = {
        varId: size.varId,
        name: pizza.name,
        size: size.size,
        price: size.price,
    }
    order.pizzaList ??= [];
    order.pizzaList.push(pizzaOrder);
    order.totalPrice += pizzaOrder.price;
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Přidá objednávku salátu uživateli.
 *
 * @param login login uživatele
 * @param salat zvolený salát
 */
export async function addSalatOrder(login: string, salat: Salat) {
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
    }
    let order: PizzaOrder | undefined = clientData.pizzaDay?.orders?.find(o => o.customer === login);
    if (!order) {
        order = {
            customer: login,
            pizzaList: [],
            totalPrice: 0,
            hasQr: false,
        }
        clientData.pizzaDay.orders ??= [];
        clientData.pizzaDay.orders.push(order);
    }
    const salatOrder: PizzaVariant = {
        varId: 0,
        name: salat.name,
        size: "1 porce",
        price: salat.price,
        category: 'salat',
    }
    order.pizzaList ??= [];
    order.pizzaList.push(salatOrder);
    order.totalPrice += salatOrder.price;
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Odstraní všechny pizzy uživatele (celou jeho objednávku).
 * Pokud Pizza day neexistuje nebo není ve stavu CREATED, neudělá nic.
 *
 * @param login login uživatele
 * @param date datum, pro které se objednávka odstraňuje (výchozí je dnešek)
 * @returns aktuální data pro klienta
 */
export async function removeAllUserPizzas(login: string, date?: Date) {
    const usedDate = date ?? getToday();
    const today = formatDate(usedDate);
    const clientData = await getClientData(usedDate);

    if (!clientData.pizzaDay) {
        return clientData; // Pizza day neexistuje, není co mazat
    }

    if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
        return clientData; // Pizza day není ve stavu CREATED, nelze mazat
    }

    const orderIndex = clientData.pizzaDay.orders!.findIndex(o => o.customer === login);
    if (orderIndex >= 0) {
        clientData.pizzaDay.orders!.splice(orderIndex, 1);
        await storage.setData(today, clientData);
    }

    return clientData;
}

/**
 * Odstraní danou objednávku pizzy.
 *
 * @param login login uživatele
 * @param pizzaOrder objednávka pizzy
 */
export async function removePizzaOrder(login: string, pizzaOrder: PizzaVariant) {
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    const orderIndex = clientData.pizzaDay.orders!.findIndex(o => o.customer === login);
    if (orderIndex < 0) {
        throw Error("Nebyly nalezeny žádné objednávky pro uživatele " + login);
    }
    const order = clientData.pizzaDay.orders![orderIndex];
    const index = order.pizzaList!.findIndex(o => o.name === pizzaOrder.name && o.size === pizzaOrder.size);
    if (index < 0) {
        throw Error("Objednávka s danými parametry nebyla nalezena");
    }
    const price = order.pizzaList![index].price;
    order.pizzaList!.splice(index, 1);
    order.totalPrice -= price;
    if (order.pizzaList!.length == 0) {
        clientData.pizzaDay.orders!.splice(orderIndex, 1);
    }
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Uzamkne možnost editovat objednávky pizzy.
 *
 * @param login login uživatele
 * @returns aktuální data pro uživatele
 */
export async function lockPizzaDay(login: string) {
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.creator !== login) {
        throw Error("Pizza day není spravován uživatelem " + login);
    }
    if (clientData.pizzaDay.state !== PizzaDayState.CREATED && clientData.pizzaDay.state !== PizzaDayState.ORDERED) {
        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED + " nebo " + PizzaDayState.ORDERED);
    }
    clientData.pizzaDay.state = PizzaDayState.LOCKED;
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Odekmne možnost editovat objednávky pizzy.
 *
 * @param login login uživatele
 * @returns aktuální data pro uživatele
 */
export async function unlockPizzaDay(login: string) {
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.creator !== login) {
        throw Error("Pizza day není spravován uživatelem " + login);
    }
    if (clientData.pizzaDay.state !== PizzaDayState.LOCKED) {
        throw Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
    }
    clientData.pizzaDay.state = PizzaDayState.CREATED;
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Nastaví stav pizza day na "pizzy objednány".
 *
 * @param login login uživatele
 * @returns aktuální data pro uživatele
 */
export async function finishPizzaOrder(login: string) {
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.creator !== login) {
        throw Error("Pizza day není spravován uživatelem " + login);
    }
    if (clientData.pizzaDay.state !== PizzaDayState.LOCKED) {
        throw Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
    }
    clientData.pizzaDay.state = PizzaDayState.ORDERED;
    await storage.setData(today, clientData);
    callNotifikace({ input: { udalost: UdalostEnum.OBJEDNANA_PIZZA, user: clientData?.pizzaDay?.creator } })
    return clientData;
}

/**
 * Nastaví stav pizza day na "pizzy doručeny".
 * Vygeneruje QR kódy pro všechny objednatele, pokud objednávající má vyplněné číslo účtu a jméno.
 *
 * @param login login uživatele
 * @returns aktuální data pro uživatele
 */
export async function finishPizzaDelivery(login: string, bankAccount?: string, bankAccountHolder?: string) {
    const today = formatDate(getToday());
    const clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.creator !== login) {
        throw Error("Pizza day není spravován uživatelem " + login);
    }
    if (clientData.pizzaDay.state !== PizzaDayState.ORDERED) {
        throw Error("Pizza day není ve stavu " + PizzaDayState.ORDERED);
    }
    clientData.pizzaDay.state = PizzaDayState.DELIVERED;

    // Vygenerujeme QR kód, pokud k tomu máme data
    if (bankAccount?.length && bankAccountHolder?.length) {
        for (const order of clientData.pizzaDay.orders!) {
            if (order.customer !== login) { // zatím platí creator = objednávající, a pro toho nemá QR kód smysl
                const id = crypto.randomUUID();
                let message = order.pizzaList!.map(item =>
                    item.category === 'salat' ? `Salát ${item.name}` : `Pizza ${item.name} (${item.size})`
                ).join(', ');
                await generateQr(order.customer, bankAccount, bankAccountHolder, order.totalPrice, message, id);
                order.hasQr = true;
                // Uložíme nevyřízený QR kód pro persistentní zobrazení
                await addPendingQr(order.customer, {
                    id,
                    date: today,
                    creator: login,
                    totalPrice: order.totalPrice,
                    purpose: message,
                });
            }
        }
    }
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Aktualizuje poznámku k Pizza day uživatele.
 * 
 * @param login přihlašovací jméno uživatele
 * @param note nová poznámka k Pizza day
 * @returns aktuální klientská data
 */
export async function updatePizzaDayNote(login: string, note?: string) {
    const today = formatDate(getToday());
    let clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
    }
    const myOrder = clientData.pizzaDay.orders!.find(o => o.customer === login);
    if (!myOrder?.pizzaList?.length) {
        throw Error("Pizza day neobsahuje žádné objednávky uživatele " + login);
    }
    myOrder.note = note;
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Aktualizuje příplatek uživatele k objednávce pizzy.
 * V případě nevyplnění ceny je příplatek odebrán.
 * 
 * @param login přihlašovací jméno aktuálního uživatele
 * @param targetLogin přihlašovací jméno uživatele, kterému je nastavován příplatek
 * @param text text popisující příplatek
 * @param price celková cena příplatku
 */
export async function updatePizzaFee(login: string, targetLogin: string, text?: string, price?: number) {
    const today = formatDate(getToday());
    let clientData = await getClientData(getToday());
    if (!clientData.pizzaDay) {
        throw Error("Pizza day pro dnešní den neexistuje");
    }
    if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
        throw Error(`Pizza day není ve stavu ${PizzaDayState.CREATED}`);
    }
    if (clientData.pizzaDay.creator !== login) {
        throw Error("Příplatky může měnit pouze zakladatel Pizza day");
    }
    const targetOrder = clientData.pizzaDay.orders!.find(o => o.customer === targetLogin);
    if (!targetOrder?.pizzaList?.length) {
        throw Error(`Pizza day neobsahuje žádné objednávky uživatele ${targetLogin}`);
    }
    if (!price) {
        delete targetOrder.fee;
    } else {
        targetOrder.fee = { text, price };
    }
    // Přepočet ceny
    targetOrder.totalPrice = targetOrder.pizzaList.reduce((price, pizzaOrder) => price + pizzaOrder.price, 0) + (targetOrder.fee?.price ?? 0);
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Vrátí klíč pro uložení nevyřízených QR kódů uživatele.
 */
function getPendingQrKey(login: string): string {
    return `${PENDING_QR_PREFIX}_${login}`;
}

/**
 * Přidá nevyřízený QR kód pro uživatele.
 */
export async function addPendingQr(login: string, pendingQr: PendingQr): Promise<void> {
    const key = getPendingQrKey(login);
    const existing = await storage.getData<PendingQr[]>(key) ?? [];
    // Deduplikace podle id (ne podle data — jeden den může mít uživatel víc QR kódů)
    if (!existing.some(qr => qr.id === pendingQr.id)) {
        existing.push(pendingQr);
        await storage.setData(key, existing);
    }
}

/**
 * Vrátí nevyřízené QR kódy pro uživatele.
 */
export async function getPendingQrs(login: string): Promise<PendingQr[]> {
    return await storage.getData<PendingQr[]>(getPendingQrKey(login)) ?? [];
}

/**
 * Označí QR kód jako uhrazený (odstraní ho ze seznamu nevyřízených).
 * Vrátí odstraněný QR kód, pokud byl nalezen.
 */
export async function dismissPendingQr(login: string, id: string): Promise<PendingQr | undefined> {
    const key = getPendingQrKey(login);
    const existing = await storage.getData<PendingQr[]>(key) ?? [];
    const dismissed = existing.find(qr => qr.id === id);
    const filtered = existing.filter(qr => qr.id !== id);
    await storage.setData(key, filtered);
    return dismissed;
}

/**
 * Odstraní všechny nevyřízené QR kódy patřící dané skupině objednávky.
 */
export async function removePendingQrsByGroupId(logins: string[], groupId: string): Promise<void> {
    for (const login of logins) {
        const key = getPendingQrKey(login);
        const existing = await storage.getData<PendingQr[]>(key) ?? [];
        const filtered = existing.filter(qr => qr.groupId !== groupId);
        if (filtered.length !== existing.length) {
            await storage.setData(key, filtered);
        }
    }
}