import { formatDate, getHumanDate, getHumanTime, getIsWeekend } from "./utils";
import { callNotifikace } from "./notifikace";
import { generateQr } from "./qr";
import { ClientData, PizzaDayState, UdalostEnum, Pizza, PizzaSize, Order, PizzaOrder, Locations, Restaurants, Food, Menu } from "../../types";
import getStorage from "./storage";
import { getMenuSladovnicka, getMenuTechTower, getMenuUMotliku } from "./restaurants";
import { downloadPizzy } from "./chefie";

const storage = getStorage();

/** Vrátí dnešní datum, případně fiktivní datum pro účely vývoje a testování. */
function getToday(): Date {
    if (process.env.MOCK_DATA === 'true') {
        return new Date('2023-05-31');
    }
    return new Date();
}

/** Vrátí "prázdná" (implicitní) data, pokud ještě nikdo nehlasoval. */
function getEmptyData(): ClientData {
    return { date: getHumanDate(getToday()), isWeekend: getIsWeekend(getToday()), choices: {} };
}

/**
 * Vrátí veškerá klientská data pro aktuální den.
 */
export async function getData(): Promise<ClientData> {
    return await storage.getData(formatDate(getToday())) || getEmptyData();
}

/**
 * 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();
    const today = formatDate(getToday());
    let clientData: ClientData = await storage.getData(today);
    if (!clientData.pizzaList) {
        clientData = await savePizzaList(await downloadPizzy());
    }
    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: ClientData = await storage.getData(today);
    clientData.pizzaList = pizzaList;
    clientData.pizzaListLastUpdate = new Date();
    await storage.setData(today, clientData);
    return clientData;
}

/**
 * Vrátí menu dané restaurace pro předaný den. Pokud neexistuje, provede jeho stažení a uložení do DB.
 * 
 * @param restaurant restaurace
 * @param date datum
 * @param mock příznak, zda chceme pouze mock data
 */
export async function getRestaurantMenu(restaurant: Restaurants, date?: Date, mock?: boolean): Promise<Menu> {
    await initIfNeeded();
    const today = formatDate(getToday());
    const clientData: ClientData = await storage.getData(today);
    if (!clientData.menus) {
        clientData.menus = {};
        storage.setData(today, clientData);
    }
    if (!clientData?.menus?.[restaurant]) {
        clientData.menus[restaurant] = {
            lastUpdate: getHumanTime(new Date()),
            closed: false,
            food: [],
        };
        switch (restaurant) {
            case Restaurants.SLADOVNICKA:
                clientData.menus[restaurant].food = await getMenuSladovnicka(date, mock);
                break;
            case Restaurants.UMOTLIKU:
                const uMotlikuFood = await getMenuUMotliku(date, mock);
                clientData.menus[restaurant].food = uMotlikuFood;
                if (uMotlikuFood.length === 1 && uMotlikuFood[0].name.toLowerCase() === 'zavřeno') {
                    clientData.menus[restaurant].closed = true;
                }
                break;
            case Restaurants.TECHTOWER:
                clientData.menus[restaurant].food = await getMenuTechTower(date, mock);
                break;
        }
        storage.setData(today, clientData);
    }
    return clientData?.menus?.[restaurant];
}

/**
 * Vytvoří pizza day pro aktuální den a vrátí data pro klienta.
 */
export async function createPizzaDay(creator: string): Promise<ClientData> {
    await initIfNeeded();
    const today = formatDate(getToday());
    const clientData: ClientData = await storage.getData(today);
    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 = await getPizzaList();
    const data: ClientData = { pizzaDay: { state: PizzaDayState.CREATED, creator, orders: [] }, pizzaList, ...clientData };
    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 today = formatDate(getToday());
    const clientData: ClientData = await storage.getData(today);
    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;
    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: ClientData = await storage.getData(today);
    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: Order | undefined = clientData.pizzaDay.orders.find(o => o.customer === login);
    if (!order) {
        order = {
            customer: login,
            pizzaList: [],
            totalPrice: 0,
        }
        clientData.pizzaDay.orders.push(order);
    }
    const pizzaOrder: PizzaOrder = {
        varId: size.varId,
        name: pizza.name,
        size: size.size,
        price: size.price,
    }
    order.pizzaList.push(pizzaOrder);
    order.totalPrice += pizzaOrder.price;
    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: PizzaOrder) {
    const today = formatDate(getToday());
    const clientData: ClientData = await storage.getData(today);
    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: ClientData = await storage.getData(today);
    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: ClientData = await storage.getData(today);
    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: ClientData = await storage.getData(today);
    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: ClientData = await storage.getData(today);
    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
    // TODO berka je potřeba počkat na resolve promises z generateQr a až poté volat save do DB
    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
                let message = order.pizzaList.map(pizza => `Pizza ${pizza.name} (${pizza.size})`).join(', ');
                const price = order.pizzaList.map(pizza => pizza.price).reduce((partial, a) => partial + a, 0);
                generateQr(order.customer, bankAccount, bankAccountHolder, price, message).then(() => order.hasQr = true);
            }
        }
    }
    await storage.setData(today, clientData);
    return clientData;
}

export async function initIfNeeded() {
    const today = formatDate(getToday());
    const hasData = await storage.hasData(today);
    if (!hasData) {
        await storage.setData(today, getEmptyData());
    }
}

/**
 * Odstraní kompletně volbu uživatele (včetně případných podřízených jídel).
 * 
 * @param login login uživatele
 * @param location vybrané "umístění"
 * @returns 
 */
export async function removeChoices(login: string, location: Locations) {
    const today = formatDate(getToday());
    let data: ClientData = await storage.getData(today);
    // TODO zajistit, že neověřený uživatel se stejným loginem nemůže mazat volby ověřeného
    if (location in data.choices) {
        if (login in data.choices[location]) {
            delete data.choices[location][login]
            if (Object.keys(data.choices[location]).length === 0) {
                delete data.choices[location]
            }
            await storage.setData(today, data);
        }
    }
    return data;
}

/**
 * Odstraní konkrétní volbu jídla uživatele.
 * Neodstraňuje volbu samotnou, k tomu slouží {@link removeChoices}.
 * 
 * @param login login uživatele
 * @param location vybrané "umístění"
 * @param foodIndex index jídla v jídelním lístku daného umístění, pokud existuje
 * @returns 
 */
export async function removeChoice(login: string, location: Locations, foodIndex: number) {
    const today = formatDate(getToday());
    let data: ClientData = await storage.getData(today);
    // TODO řešit ověření uživatele
    if (location in data.choices) {
        if (login in data.choices[location]) {
            const index = data.choices[location][login].options.indexOf(foodIndex);
            if (index > -1) {
                data.choices[location][login].options.splice(index, 1)
                await storage.setData(today, data);
            }
        }
    }
    return data;
}

/**
 * Odstraní kompletně volbu uživatele.
 * 
 * @param login login uživatele
 */
async function removeChoiceIfPresent(login: string) {
    const today = formatDate(getToday());
    let data: ClientData = await storage.getData(today);
    for (const key of Object.keys(data.choices)) {
        if (login in data.choices[key]) {
            delete data.choices[key][login];
            if (Object.keys(data.choices[key]).length === 0) {
                delete data.choices[key];
            }
            await storage.setData(today, data);
        }
    }
    return data;
}

/**
 * Přidá volbu uživatele.
 * 
 * @param login login uživatele
 * @param location vybrané "umístění"
 * @param foodIndex volitelný index jídla v daném umístění
 * @param trusted příznak, zda se jedná o ověřeného uživatele
 * @returns aktuální data
 */
export async function addChoice(login: string, trusted: boolean, location: Locations, foodIndex?: number) {
    await initIfNeeded();
    const today = formatDate(getToday());
    let data: ClientData = await storage.getData(today);
    // Ověření, že se neověřený užívatel nepokouší přepsat údaje ověřeného
    const locations = Object.values(data?.choices);
    let found = false;
    if (!trusted) {
        for (const location of locations) {
            if (Object.keys(location).includes(login) && location[login].trusted) {
                found = true;
            }
        }
    }
    if (!trusted && found) {
        throw Error("Nelze změnit volbu ověřeného uživatele");
    }
    // Pokud měníme pouze lokaci, mažeme případné předchozí
    if (foodIndex == null) {
        data = await removeChoiceIfPresent(login);
    }
    if (!(location in data.choices)) {
        data.choices[location] = {};
    }
    if (!(login in data.choices[location])) {
        data.choices[location][login] = {
            trusted,
            options: []
        };
    }
    if (foodIndex != null && !data.choices[location][login].options.includes(foodIndex)) {
        data.choices[location][login].options.push(foodIndex);
    }
    await storage.setData(today, data);
    return data;
}

// TODO přejmenovat, ať je jasné že to patří k pizza day
export async function updateNote(login: string, note?: string) {
    const today = formatDate(getToday());
    let clientData: ClientData = await storage.getData(today);
    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 || !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 preferovaný čas odchodu strávníka.
 * 
 * @param login login uživatele
 * @param time preferovaný čas odchodu
 */
export async function updateDepartureTime(login: string, time?: string) {
    const today = formatDate(getToday());
    let clientData: ClientData = await storage.getData(today);
    const found = Object.values(clientData.choices).find(location => login in location);
    // TODO validace, že se jedná o restauraci
    if (found) {
        if (!time?.length) {
            delete found[login].departureTime;
        } else {
            found[login].departureTime = time;
        }
        await storage.setData(today, clientData);
    }
    return clientData;
}