import { InsufficientPermissions, formatDate, getDayOfWeekIndex, getHumanDate, getHumanTime, getIsWeekend } from "./utils";
import { ClientData, Locations, Restaurants, Menu, DepartureTime } from "../../types";
import getStorage from "./storage";
import { getMenuSladovnicka, getMenuTechTower, getMenuUMotliku } from "./restaurants";
import { getTodayMock } from "./mock";

const storage = getStorage();

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

/** Vrátí datum v aktuálním týdnu na základě předaného indexu (0 = pondělí). */
export const getDateForWeekIndex = (index: number) => {
    if (index < 0 || index > 4) {
        // Nechceme shodit server, vrátíme dnešek
        console.log('Neplatný index dne v týdnu: ' + index);
        return getToday();
    }
    const date = getToday();
    date.setDate(date.getDate() - getDayOfWeekIndex(date) + index);
    return date;
}

/** Vrátí "prázdná" (implicitní) data pro předaný den. */
function getEmptyData(date?: Date): ClientData {
    const usedDate = date || getToday();
    return {
        date: getHumanDate(usedDate),
        isWeekend: getIsWeekend(usedDate),
        weekIndex: getDayOfWeekIndex(usedDate),
        choices: {},
        departureTimes: Object.values(DepartureTime),
    };
}

/**
 * Vrátí veškerá klientská data pro předaný den, nebo aktuální den, pokud není předán.
 */
export async function getData(date?: Date): Promise<ClientData> {
    const dateString = formatDate(date ?? getToday());
    const data = await storage.getData(dateString) || getEmptyData(date);
    data.todayWeekIndex = getDayOfWeekIndex(getToday());
    // Dotažení jídel, pokud je ještě nemáme
    if (!data.menus) {
        data.menus = {
            [Restaurants.SLADOVNICKA]: await getRestaurantMenu(Restaurants.SLADOVNICKA, date ?? getToday()),
            [Restaurants.UMOTLIKU]: await getRestaurantMenu(Restaurants.UMOTLIKU, date ?? getToday()),
            [Restaurants.TECHTOWER]: await getRestaurantMenu(Restaurants.TECHTOWER, date ?? getToday()),
        }
        await storage.setData(dateString, data);
    }
    return data;
}

// TODO přesun do restaurants.ts
/**
 * 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): Promise<Menu> {
    await initIfNeeded(date);
    const selectedDay = formatDate(date ?? getToday());
    const clientData: ClientData = await storage.getData(selectedDay);
    if (!clientData.menus) {
        clientData.menus = {};
        storage.setData(selectedDay, clientData);
    }
    if (!clientData.menus[restaurant]) {
        clientData.menus[restaurant] = {
            lastUpdate: getHumanTime(new Date()),
            closed: false,
            food: [],
        };
        const mock = process.env.MOCK_DATA === 'true';
        switch (restaurant) {
            case Restaurants.SLADOVNICKA:
                const sladovnickaFood = await getMenuSladovnicka(date, mock);
                clientData.menus[restaurant]!.food = sladovnickaFood;
                // Velice chatrný a nespolehlivý způsob detekce uzavření...
                if (sladovnickaFood.length === 1 && sladovnickaFood[0].name.toLowerCase() === 'pro daný den nebyla nalezena denní nabídka') {
                    clientData.menus[restaurant]!.closed = true;
                }
                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:
                const techTowerFood = await getMenuTechTower(date, mock);
                clientData.menus[restaurant]!.food = techTowerFood;
                if (techTowerFood.length === 1 && techTowerFood[0].name.toLowerCase() === 'svátek') {
                    clientData.menus[restaurant]!.closed = true;
                }
                break;
        }
        storage.setData(selectedDay, clientData);
    }
    return clientData.menus[restaurant]!;
}

export async function initIfNeeded(date?: Date) {
    const usedDate = formatDate(date ?? getToday());
    const hasData = await storage.hasData(usedDate);
    if (!hasData) {
        await storage.setData(usedDate, getEmptyData(date || getToday()));
    }
}

/**
 * Odstraní kompletně volbu uživatele (včetně případných podřízených jídel).
 * 
 * @param login login uživatele
 * @param trusted příznak, zda se jedná o ověřeného uživatele
 * @param location vybrané "umístění"
 * @param date datum, ke kterému se volba vztahuje
 * @returns 
 */
export async function removeChoices(login: string, trusted: boolean, location: Locations, date?: Date) {
    const selectedDay = formatDate(date ?? getToday());
    let data: ClientData = await storage.getData(selectedDay);
    validateTrusted(data, login, trusted);
    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(selectedDay, 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 trusted příznak, zda se jedná o ověřeného 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
 * @param date datum, ke kterému se volba vztahuje
 * @returns 
 */
export async function removeChoice(login: string, trusted: boolean, location: Locations, foodIndex: number, date?: Date) {
    const selectedDay = formatDate(date ?? getToday());
    let data: ClientData = await storage.getData(selectedDay);
    validateTrusted(data, login, trusted);
    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(selectedDay, data);
            }
        }
    }
    return data;
}

/**
 * Odstraní kompletně volbu uživatele.
 * 
 * @param login login uživatele
 */
async function removeChoiceIfPresent(login: string, date: string) {
    let data: ClientData = await storage.getData(date);
    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(date, data);
        }
    }
    return data;
}

/**
 * Ověří, zda se neověřený uživatel nepokouší přepsat údaje ověřeného a případně vyhodí chybu.
 * 
 * @param data aktuální klientská data
 * @param login přihlašovací jméno uživatele
 * @param trusted příznak, zda se jedná o ověřeného uživatele
 */
function validateTrusted(data: ClientData, login: string, trusted: boolean) {
    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 new InsufficientPermissions("Nelze změnit volbu ověřeného uživatele");
    }
}

/**
 * Přidá volbu uživatele.
 * 
 * @param login login uživatele
 * @param trusted příznak, zda se jedná o ověřeného 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
 * @param date datum, ke kterému se volba vztahuje
 * @returns aktuální data
 */
export async function addChoice(login: string, trusted: boolean, location: Locations, foodIndex?: number, date?: Date) {
    await initIfNeeded();
    const selectedDate = formatDate(date ?? getToday());
    let data: ClientData = await storage.getData(selectedDate);
    validateTrusted(data, login, trusted);
    // Pokud měníme pouze lokaci, mažeme případné předchozí
    if (foodIndex == null) {
        data = await removeChoiceIfPresent(login, selectedDate);
    }
    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(selectedDate, data);
    return data;
}

/**
 * Aktualizuje preferovaný čas odchodu strávníka.
 * 
 * @param login login uživatele
 * @param time preferovaný čas odchodu
 * @param date datum, ke kterému se čas vztahuje
 */
export async function updateDepartureTime(login: string, time?: string, date?: Date) {
    const selectedDate = formatDate(date ?? getToday());
    let clientData: ClientData = await storage.getData(selectedDate);
    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 {
            if (!Object.values<string>(DepartureTime).includes(time)) {
                throw Error(`Neplatný čas odchodu ${time}`);
            }
            found[login].departureTime = time;
        }
        await storage.setData(selectedDate, clientData);
    }
    return clientData;
}