import {defineStore} from 'pinia'
import * as dayJs from "dayjs"

//const supabase = createClient('https://uwppvcxflrcsibuzsbil.supabase.co','eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InV3cHB2Y3hmbHJjc2lidXpzYmlsIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MDA5MzgxOTQsImV4cCI6MjAxNjUxNDE5NH0.CkxYSQH0uLfwx9GVUlO6AYMU2FMLAxGMrwEKvyPv7Oo')

// @ts-ignore
export const useDataStore = defineStore('data', () => {

    const supabase = useSupabaseClient()
    const user = useSupabaseUser()
    const toast = useToast()

    const loaded = ref(false)
    const ownTenant = ref({
        calendarConfig: {
            eventTypes: [] as any[]
        },
        timeConfig: {
            timeTypes: [] as any[]
        },
        tags: {
            documents: [] as any[],
                products: [] as any[]
        }
    })
    const profiles = ref([])
    const events = ref([])
    const customers = ref([])
    const tasks = ref([])
    const projects = ref([])
    const documents = ref([])
    const spaces = ref([])
    const units = ref([])
    const times = ref([])
    const products = ref([])
    const movements = ref([])
    const forms = ref([])
    const contracts = ref([])
    const jobs = ref([])
    const formSubmits = ref([])
    const contacts = ref([])
    const vehicles = ref([])
    const vendors = ref([])
    const vendorInvoices = ref([])
    const bankAccounts = ref([])
    const bankStatements = ref([])
    const historyItems = ref([])
    const numberRanges = ref([])
    const notifications = ref([])
    const absenceRequests = ref([])
    const accounts = ref([])
    const taxTypes = ref([])

    async function fetchData () {
        fetchDocuments()
        await fetchOwnTenant()
        await fetchProfiles()
        await fetchEvents()
        await fetchTasks()
        await fetchProjects()
        await fetchTimes()
        await fetchJobs()
        await fetchCustomers()
        await fetchContracts()
        await fetchContacts()
        await fetchForms()
        await fetchFormSubmits()
        await fetchProducts()
        await fetchUnits()
        //await fetchDocuments()
        await fetchMovements()
        await fetchSpaces()
        await fetchVehicles()
        await fetchVendors()
        await fetchVendorInvoices()
        await fetchBankAccounts()
        await fetchBankStatements()
        await fetchHistoryItems()
        await fetchNumberRanges()
        await fetchNotifications()
        await fetchAbsenceRequests()
        await fetchAccounts()
        await fetchTaxTypes()
        loaded.value = true
    }

    function clearStore () {
        console.log("Clear")
        loaded.value = false
        ownTenant.value =  {}
        profiles.value= []
        events.value= []
        customers.value= []
        tasks.value= []
        projects.value= []
        documents.value= []
        spaces.value= []
        units.value= []
        times.value= []
        products.value= []
        movements.value= []
        forms.value= []
        contracts.value= []
        jobs.value= []
        formSubmits.value= []
        contacts.value= []
        vehicles.value= []
        vendors.value= []
        vendorInvoices.value= []
        bankAccounts.value= []
        bankStatements.value= []
        historyItems.value = []
        numberRanges.value = []
        notifications.value = []
        absenceRequests.value = []
        accounts.value = []
        taxTypes.value = []
    }

    async function fetchOwnTenant () {
        ownTenant.value = (await supabase.from("tenants").select().eq('id', user.value?.app_metadata.tenant)).data[0]
    }

    async function fetchProfiles () {
        profiles.value = (await supabase.from("profiles").select()).data
    }
    async function fetchBankAccounts () {
        bankAccounts.value = (await supabase.from("bankAccounts").select()).data
    }
    async function fetchBankStatements () {
        bankStatements.value = (await supabase.from("bankStatements").select().order("date", {ascending:false})).data
    }
    async function fetchEvents () {
        events.value = (await supabase.from("events").select()).data
    }
    async function fetchContracts () {
        contracts.value = (await supabase.from("contracts").select()).data
    }
    async function fetchContacts () {
        contacts.value = (await supabase.from("contacts").select()).data
    }
    async function fetchCustomers () {
        customers.value = (await supabase.from("customers").select().order("customerNumber", {ascending:true})).data
    }
    async function fetchTasks () {
        tasks.value = (await supabase.from("tasks").select()).data
    }
    async function fetchForms () {
        forms.value = (await supabase.from("forms").select()).data
    }
    async function fetchFormSubmits () {
        formSubmits.value = (await supabase.from("formSubmits").select()).data
    }
    async function fetchProducts () {
        products.value = (await supabase.from("products").select()).data
    }
    async function fetchUnits () {
        units.value = (await supabase.from("units").select()).data
    }
    async function fetchProjects () {
        projects.value = (await supabase.from("projects").select()).data
    }
    async function fetchSpaces () {
        spaces.value = (await supabase.from("spaces").select().order("spaceNumber", {ascending:true})).data
    }
    async function fetchMovements () {
        movements.value = (await supabase.from("movements").select()).data
    }
    async function fetchVehicles () {
        vehicles.value = (await supabase.from("vehicles").select()).data
    }
    async function fetchTimes () {
        times.value = (await supabase.from("times").select()).data
    }
    async function fetchJobs () {
        jobs.value = (await supabase.from("jobs").select()).data
    }
    async function fetchHistoryItems () {
        historyItems.value = (await supabase.from("historyItems").select()).data
    }
    async function fetchVendors () {
        vendors.value = (await supabase.from("vendors").select().order("vendorNumber", {ascending:true})).data
    }
    async function fetchVendorInvoices () {
        vendorInvoices.value = (await supabase.from("vendorInvoices").select()).data
    }
    async function fetchNumberRanges () {
        numberRanges.value = (await supabase.from("numberRanges").select()).data
    }
    async function fetchNotifications () {
        notifications.value = (await supabase.from("notifications").select().order("created_at", {ascending: false})).data
    }
    async function fetchAbsenceRequests () {
        absenceRequests.value = (await supabase.from("absenceRequests").select()).data
    }
    async function fetchAccounts () {
        accounts.value = (await supabase.from("accounts").select()).data
    }
    async function fetchTaxTypes () {
        taxTypes.value = (await supabase.from("taxTypes").select()).data
    }

    async function fetchDocuments () {
        documents.value = (await supabase.from("documents").select()).data

        for(const [index,doc] of documents.value.entries()){
            // @ts-ignore
            documents.value[index].url = (await supabase.storage.from('files').createSignedUrl(doc.path, 60 * 60)).data.signedUrl
        }
    }

    async function addHistoryItem(text: String, user: String, elementId: String, resourceType: String) {
        let data = {
            user: user,
            text: text
        }

        if(resourceType === "customers") {
            data.customer = elementId
        }

        const {data:insertData,error:insertError} = await supabase
            .from("historyItems")
            .insert([addHistoryItemData.value])
            .select()

        if(insertError) {
            console.log(insertError)
        } else {
            toast.add({title: "Eintrag erfolgreich erstellt"})
            await fetchHistoryItems()
        }

    }

    //Getters

    const getOpenTasksCount = computed(() => {
        return tasks.value.filter(task => task.categorie != "Erledigt").length
    })

    const getMovementsBySpace = computed(() => (spaceId:string) => {
        return movements.value.filter(movement => movement.spaceId === spaceId)
    })

    const getContactsByCustomerId = computed(() => (customerId:string) => {
        return contacts.value.filter(item => item.customer === customerId)
    })

    const getContactsByVendorId = computed(() => (vendorId:string) => {
        return contacts.value.filter(item => item.vendor === vendorId)
    })

    const getDocumentsByProjectId = computed(() => (projectId:string) => {
        return documents.value.filter(item => item.project === projectId)
    })

    const getTimesByProjectId = computed(() => (projectId:string) => {
        return times.value.filter(time => time.projectId === projectId)
    })

    const getTasksByProjectId = computed(() => (projectId:string) => {
        return tasks.value.filter(item => item.project === projectId)
    })



    const getHistoryItemsByCustomer = computed(() => (customerId:string) => {
        return historyItems.value.filter(item => item.customer === customerId)
    })

    const getHistoryItemsByVendor = computed(() => (vendorId:string) => {
        return historyItems.value.filter(item => item.vendor === vendorId)
    })

    const getMovementsBySpaceId = computed(() => (spaceId:string) => {
        return movements.value.filter(movement => movement.spaceId === spaceId)
    })

    const getStockByProductId = computed(() => (productId:string) => {
        let productMovements = movements.value.filter(movement => movement.productId === productId)

        let count = 0

        productMovements.forEach(movement => {
            count += movement.quantity
        })

        return count
    })

    const getEventTypes = computed(() => {
        return ownTenant.value.calendarConfig.eventTypes
    })

    const getTimeTypes = computed(() => {
        return ownTenant.value.timeConfig.timeTypes
    })

    const getDocumentTags = computed(() => {
        return ownTenant.value.tags.documents
    })

    const getResources = computed(() => {
        return [
            ...profiles.value.map(profile => {
                return {
                    type: 'person',
                    title: profile.fullName,
                    id: profile.id
                }
            }),
            ...vehicles.value.map(vehicle => {
                return {
                    type: 'vehicle',
                    title: vehicle.licensePlate,
                    id: vehicle.licensePlate
                }
            })
        ]
    })

    const getEvents = computed(() => {
        return [
            ...events.value.map(event => {
                let eventColor = ownTenant.value.calendarConfig.eventTypes.find(type => type.label === event.type).color

                return {
                    ...event,
                    borderColor: eventColor,
                    textColor: eventColor,
                    backgroundColor: "black"
                }
            }),
            ...absenceRequests.value.map(absence => {
                return  {
                    resourceId: absence.user,
                    resourceType: "person",
                    title: absence.reason,
                    start: dayJs(absence.start).toDate(),
                    end: dayJs(absence.end).add(1,'day').toDate(),
                    allDay: true
                }
            })
        ]
    })


    //Get Item By Id
    const getProductById = computed(() => (itemId:string) => {
        return products.value.find(item => item.id === itemId)
    })

    const getVendorById = computed(() => (itemId:string) => {
        return vendors.value.find(item => item.id === itemId)
    })

    const getVendorInvoiceById = computed(() => (itemId:string) => {
        return vendorInvoices.value.find(item => item.id === itemId)
    })

    const getContractById = computed(() => (itemId:string) => {
        return contracts.value.find(item => item.id === itemId)
    })

    const getContactById = computed(() => (itemId:string) => {
        return contacts.value.find(item => item.id === itemId)
    })

    const getVehicleById = computed(() => (itemId:string) => {
        return vehicles.value.find(item => item.id === itemId)
    })

    const getDocumentById = computed(() => (itemId:string) => {
        return documents.value.find(item => item.id === itemId)
    })

    const getSpaceById = computed(() => (itemId:string) => {
        return spaces.value.find(item => item.id === itemId)
    })

    const getCustomerById = computed(() => (itemId:number) => {
        return customers.value.find(item => item.id === itemId)
    })

    const getJobById = computed(() => (itemId:string) => {
        return jobs.value.find(item => item.id === itemId)
    })

    const getAbsenceRequestById = computed(() => (itemId:string) => {
        return absenceRequests.value.find(item => item.id === itemId)
    })

    const getProfileById = computed(() => (itemId:string) => {
        return profiles.value.find(item => item.id === itemId)
    })

    const getAccountById = computed(() => (accountId:string) => {
        return accounts.value.find(item => item.id === accountId)
    })

    const getProjectById = computed(() => (itemId:string) => {
        let project = projects.value.find(project => project.id === itemId)

        let projectHours = 0

        let projectTimes = times.value.filter(time => time.projectId === itemId)
        projectTimes.forEach(time => projectHours += time.duration)

        project.projectHours = projectHours

        return project
    })

    return {
        loaded,
        ownTenant,
        profiles,
        events,
        customers,
        tasks,
        projects,
        documents,
        spaces,
        units,
        times,
        products,
        movements,
        forms,
        contracts,
        jobs,
        formSubmits,
        contacts,
        vehicles,
        vendors,
        vendorInvoices,
        bankAccounts,
        bankStatements,
        historyItems,
        numberRanges,
        notifications,
        absenceRequests,
        accounts,
        taxTypes,
        //Functions
        fetchData,
        clearStore,
        fetchOwnTenant,
        fetchProfiles,
        fetchBankAccounts,
        fetchBankStatements,
        fetchEvents,
        fetchContracts,
        fetchContacts,
        fetchCustomers,
        fetchTasks,
        fetchForms,
        fetchFormSubmits,
        fetchProducts,
        fetchUnits,
        fetchProjects,
        fetchSpaces,
        fetchMovements,
        fetchVehicles,
        fetchTimes,
        fetchJobs,
        fetchHistoryItems,
        fetchVendors,
        fetchVendorInvoices,
        fetchNumberRanges,
        fetchNotifications,
        fetchDocuments,
        fetchAbsenceRequests,
        addHistoryItem,
        //Getters
        getOpenTasksCount,
        getMovementsBySpace,
        getContactsByCustomerId,
        getContactsByVendorId,
        getDocumentsByProjectId,
        getTimesByProjectId,
        getTasksByProjectId,
        getMovementsBySpaceId,
        getStockByProductId,
        getHistoryItemsByCustomer,
        getHistoryItemsByVendor,
        getEventTypes,
        getTimeTypes,
        getDocumentTags,
        getResources,
        getEvents,
        getProductById,
        getVendorById,
        getVendorInvoiceById,
        getContractById,
        getContactById,
        getVehicleById,
        getDocumentById,
        getSpaceById,
        getCustomerById,
        getJobById,
        getAbsenceRequestById,
        getProjectById,
        getProfileById,
        getAccountById,
    }


})