/* eslint-disable @typescript-eslint/no-unused-vars */
import React, { PropsWithChildren, useEffect, useState } from "react";
import * as authAPI from "../API/user";
import {useAsyncValue, useNavigate} from "react-router-dom";
import {
    EgovUser,
    Role,
    Permissions,
    MicroservicePermissions,
    Microservice,
    Translations,
    AppSettings
} from "../models/EgovUser";
import {logout, updateQuickAccess, getProfilePicture} from "../API/user";
import LoadingPage from "../components/UI/LoadingPage/LoadingPage";
import { cacheClear } from '../API/axios'

interface AuthContextInterface {
    isAuthenticated: boolean;
    currentUser: EgovUser | null;
    translations: Translations | null;
    appSettings: AppSettings | null
    logoutUser: () => void;
    loginUser: (user: EgovUser, translations: any) => void;
    addQuickAccess: (role: string, permission: string) => void;
    removeQuickAccess: (key: string) => void;
    reOrderQuickAccess: (q: string[]) => void;
    userAvatar: File | null
    setUserAvatar: (avatar: File | null) => void; // New function to set the avatar
}


/**
 * creates permissions per microservice per user
 * eg: rescom = {
 *     director.erga,
 *     president.simvaseis
 * }
 */
const transformPermissions = (permissions: Permissions): MicroservicePermissions => {
    const microservice_permissions: MicroservicePermissions = {};

    Object.entries(permissions).map(([role, rolePermissions]) => {
        Object.keys(rolePermissions).forEach((per: string) => {
            const [ms, module] = per.split('.');
            if (!(ms in microservice_permissions)) {

                // @ts-ignore
                microservice_permissions[ms] = [];
            }
            // @ts-ignore
            microservice_permissions[ms].push(`${role}.${module}`);
        });
    });

    /**
     * we handle the settings as an ms but its not defined in the backend
     */
    // microservice_permissions['settings'] = ['dua_user.profile',
        // 'dua_user.reminders','dua_user.notifications'
    // ]

    return microservice_permissions;
};

const AuthContext = React.createContext({} as AuthContextInterface);

export const AuthContextProvider: React.FC<PropsWithChildren> = (props) => {
    const navigate = useNavigate();
    const [requestPending, setPendingRequest] = useState(true);
    const [currentUser, setCurrentUser] = useState<EgovUser | null>(null);
    const [translations, setTranslations] = useState<Translations | null>(null);
    const [isAuthenticated, setIsAuthenticated] = useState(false);
    const [userAvatar, setUserAvatar] = useState<File | null>(null); // New state for the avatar
    const [appSettings, setAppSettings] = useState<AppSettings | null>(null)

    useEffect(() => {
        setPendingRequest(true);
        (async () => {
            setPendingRequest(true)
            try {
                const settings = await authAPI.getSettings()

                const loginIsDisabled = settings.data['disable_login']?.status === 1 ?? false;
                const ldapIsDown = settings.data['ldap_down']?.status === 1 ?? false;
                setAppSettings({
                    loginIsDisabled,
                    ldapIsDown
                })
                if (settings.data['disable_login'].status == 1) {
                    await authAPI.logout()
                    setPendingRequest(false);
                    navigate("/login");
                }
                // if (settings.data['disable_login'].status == 1) {
                //     await authAPI.logout()
                //     setPendingRequest(false);
                //     navigate("/login");
                // }
                //
                // {
                //     itemId: 86,
                //         otherParam: 'anything you want here',
                // }
            } catch (error) {
                setPendingRequest(false);
                navigate("/login");
            } finally {


            }


            const res = await authAPI.checkAuth().then(
                (res) => {
                    const newUser = {...res.data.user};
                    const translations = {...res.data.translations}
                    setUserContext(newUser, translations)

                },
                (err) => {
                }
            );
            setPendingRequest(false);
        })();
    }, []);


    /**
     * this is called after manually login or after checking sessions and user is logged in
     */
    const setUserContext = (user: EgovUser, translations: Translations) => {
        const microservice_permissions = transformPermissions(JSON.parse(JSON.stringify(user.permissions)));
        user.microservice_permissions = microservice_permissions;

        setCurrentUser(user);
        setIsAuthenticated(true);

        /***
         * Translation for settings are defined in the frontend for now (::
         */
        translations.microservices.settings ={
            view_name: 'Ρυθμίσεις',
            description: 'Ρυθμίσεις',
        }
        translations.modules['settings.profile'] = {
            view_name: 'Ρυθμίσεις Προφίλ',
            description: 'Ρυθμίστε τις επιλογές',
        }
        translations.modules['settings.notifications'] = {
            view_name: 'Ρυθμίσεις Ενημερώσεων',
            description: 'Ρυθμίστε τις επιλογές',
        }
        translations.modules['settings.reminders'] = {
            view_name: 'Ρυθμίσεις Υπενθυμίσεων',
            description: 'Ρυθμίστε τις επιλογές',
        }


        setTranslations(translations);
        fetchUserAvatar()
    };

    const fetchUserAvatar = async () =>{
        const res = await getProfilePicture()
        if (res.status === 200) {
            setUserAvatar(res.data);
        }
    }

    const addQuickAccess = async (role: any, permission: any) => {
        // const [service, module, right] = permission.split('.')
        const key = role + '.' +permission;
        if (!currentUser || currentUser.quickAccess.includes(key)) return;
        const newQuick = [...currentUser.quickAccess]
        newQuick.push(key)

        setCurrentUser({
            ...currentUser,
            quickAccess: newQuick
        })

        await updateQuickAccess(newQuick)
    }

    const removeQuickAccess = async (key: string) => {

        if (!currentUser) return;
        const newQuick = currentUser.quickAccess.filter(quick => quick !== key)

        setCurrentUser({
            ...currentUser,
            quickAccess: newQuick
        })
        await updateQuickAccess(newQuick)
    }

    const reOrderQuickAccess = async (newQuick: string[]) => {

        if (!currentUser) return;

        setCurrentUser({
            ...currentUser,
            quickAccess: newQuick
        })
        await updateQuickAccess(newQuick)
    }

    return (
        <AuthContext.Provider
            value={{
                currentUser: currentUser,
                translations: translations,
                isAuthenticated: isAuthenticated,
                appSettings:appSettings,
                logoutUser: async () => {
                    await logout()
                    setCurrentUser(null);
                    setIsAuthenticated(false);
                    cacheClear();
                    navigate("/login");
                },
                loginUser: (user, translations) => {
                    const newUser = { ...user };
                    setUserContext(newUser, translations);
                    navigate("/dashboard");
                },
                addQuickAccess: addQuickAccess,
                removeQuickAccess: removeQuickAccess,
                reOrderQuickAccess: reOrderQuickAccess,
                userAvatar: userAvatar,
                setUserAvatar: setUserAvatar, // Provide the setAvatar function
            }}
        >
            {requestPending ? <LoadingPage /> : props.children}
        </AuthContext.Provider>
    );
};

export default AuthContext;