import {defineStore} from 'pinia'
import dayjs from "dayjs"
import {typeOf} from "uri-js/dist/esnext/util";
import {useNumberRange} from "~/composables/useNumberRange.js";

//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 router = useRouter()

    const dataTypes = {
        tasks: {
            label: "Aufgaben",
            labelSingle: "Aufgabe",
            redirect: true
        },
        customers: {
            label: "Kunden",
            labelSingle: "Kunde",
            redirect:true,
            numberRangeHolder: "customerNumber"
        },
        contacts: {
            label: "Kontakte",
            labelSingle: "Kontakt",
            redirect:true
        },
        contracts: {
            label: "Verträge",
            labelSingle: "Vertrag",
            redirect:true
        },
        absenceRequests: {
            label: "Abwesenheitsanträge",
            labelSingle: "Abwesenheitsantrag",
            redirect:true
        },
        plants: {
            label: "Objekte",
            labelSingle: "Objekte",
            redirect:true
        },
        products: {
            label: "Artikel",
            labelSingle: "Artikel",
            redirect:true
        },
        projects: {
            label: "Projekte",
            labelSingle: "Projekt",
            redirect:true
        },
        vehicles: {
            label: "Fahrzeuge",
            labelSingle: "Fahrzeug",
            redirect:true
        },
        vendors: {
            label: "Lieferanten",
            labelSingle: "Lieferant",
            redirect:true,
            numberRangeHolder: "vendorNumber"
        },
        messages: {
            label: "Nachrichten",
            labelSingle: "Nachricht"
        },
        spaces: {
            label: "Lagerplätze",
            labelSingle: "Lagerplatz",
            redirect: true,
            numberRangeHolder: "spaceNumber"
        },
        users: {
            label: "Benutzer",
            labelSingle: "Benutzer"
        },
        createddocuments: {
            label: "Dokumente",
            labelSingle: "Dokument"
        },
        incominginvoices: {
            label: "Eingangsrechnungen",
            labelSingle: "Eingangsrechnung"
        },
        inventoryitems: {
            label: "Inventarartikel",
            labelSingle: "Inventarartikel",
            redirect: true
        },
        services: {
            label: "Leistungen",
            labelSingle: "Leistung",
            redirect: true
        },
    }

    const documentTypesForCreation = ref({
        invoices: {
            label: "Rechnungen",
            labelSingle: "Rechnung",

        },
        quotes: {
            label: "Angebote",
            labelSingle: "Angebot"
        },
        deliveryNotes: {
            label: "Lieferscheine",
            labelSingle: "Lieferschein"
        }
    })


    const loaded = ref(false)
    const ownTenant = ref({
        calendarConfig: {
            eventTypes: []
        },
        timeConfig: {
            timeTypes: []
        },
        tags: {
            documents: [] ,
                products: []
        },
        measures: []
    })


    const profiles = ref([])
    const currentTenant = ref(null)
    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 formSubmits = ref([])
    const contacts = ref([])
    const vehicles = ref([])
    const vendors = ref([])
    const incominginvoices = 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([])
    const plants = ref([])
    const inventoryitems = ref([])
    const chats = ref([])
    const messages = ref([])
    const createddocuments = ref([])
    const workingtimes = ref([])
    const phasesTemplates = ref([])
    const emailAccounts = ref([])
    const texttemplates =ref([])
    const services =ref([])
    const serviceCategories =ref([])


    const rights = ref({
        createUser: {label: "Benutzer erstellen"},
        modifyUser: {label: "Benutzer bearbeiten"},
        deactivateUser: {label: "Benutzer sperren"},
        createProject: {label: "Projekt erstellen"},
        viewOwnProjects: {label: "Eigene Projekte sehen"},
        viewAllProjects: {label: "Alle Projekte sehen"},
        createTask: {label: "Aufgabe erstellen"},
        viewOwnTasks: {label:"Eigene Aufgaben sehen"},
        viewAllTasks: {label: "Alle Aufgaben sehen"},
        trackOwnTime: {label:"Eigene Zeite erfassen"},
        createOwnTime: {label:"Eigene Zeiten erstellen"},
        createTime: {label:"Zeiten erstellen"},
        viewOwnTimes: {label:"Eigene Zeiten anzeigen"},
        viewTimes: {label:"Zeiten anzeigen"},
    })

    const roles = ref([
        {
            key: "tenantAdmin",
            label: "Firmenadministrator",
            rights: [
                ...Object.keys(rights.value)
            ]
        },
        {
            key:"worker",
            label: "Monteur",
            rights: [
                "viewOwnProjects",
                "createTasks",
                "viewOwnTasks",
                "viewOwnTimes",
                "createOwnTime"
            ]
        },
        {
            key:"manager",
            label: "Vorarbeiter",
            rights: [
                "createProjects",
                "viewOwnProjects",
                "createTasks",
                "viewOwnTasks",
            ]
        },
        {
            key:"booker",
            label: "Buchhalter",
            rights: [
                "createTasks",
                "viewOwnTasks",
                "createTime",
                "viewAllTimes"
            ]
        }
    ])

    async function initializeData (userId) {
        let profile = (await supabase.from("profiles").select().eq("id",userId).single()).data

        currentTenant.value = profile.tenant

        await fetchData()

    }

    async function changeTenant() {
        loaded.value = false
        await clearStore()
        await fetchData()
        router.push("/")
        loaded.value = true

    }

    async function fetchData () {
        await fetchProfiles()
        await fetchDocuments()
        await fetchOwnTenant()
        await fetchEvents()
        await fetchTasks()
        await fetchProjects()
        await fetchTimes()
        await fetchCustomers()
        await fetchContracts()
        await fetchContacts()
        await fetchForms()
        await fetchFormSubmits()
        await fetchProducts()
        await fetchUnits()
        await fetchMovements()
        await fetchSpaces()
        await fetchVehicles()
        await fetchVendors()
        await fetchIncomingInvoices()
        await fetchBankAccounts()
        await fetchBankStatements()
        await fetchHistoryItems()
        await fetchNumberRanges()
        await fetchNotifications()
        await fetchAbsenceRequests()
        await fetchAccounts()
        await fetchTaxTypes()
        await fetchPlants()
        await fetchInventoryItems()
        await fetchChats()
        await fetchMessages()
        await fetchCreatedDocuments()
        await fetchWorkingTimes()
        await fetchPhasesTemplates()
        await fetchEmailAccounts()
        await fetchTextTemplates()
        await fetchServices()
        await fetchServiceCategories()
        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= []
        formSubmits.value= []
        contacts.value= []
        vehicles.value= []
        vendors.value= []
        incominginvoices.value= []
        bankAccounts.value= []
        bankStatements.value= []
        historyItems.value = []
        numberRanges.value = []
        notifications.value = []
        absenceRequests.value = []
        accounts.value = []
        taxTypes.value = []
        plants.value = []
        inventoryitems.value = []
        chats.value = []
        messages.value = []
        createddocuments.value = []
        workingtimes.value = []
        phasesTemplates.value = []
        emailAccounts.value = []
        texttemplates.value = []
        services.value = []
        serviceCategories.value = []
    }

    function hasRight (right) {
        const role = profiles.value.find(i => i.id === user.value.id).role
        const grantedRights = roles.value.find(i => i.key === role).rights

        if(grantedRights.includes(right)){
            return true
        } else return false

    }


    //Realtime Update
    const channelA = supabase
        .channel('schema-db-changes')
        .on(
            'postgres_changes',
            {
                event: '*',
                schema: 'public',
            },
            (payload) => {
                //console.log(payload)

                /*if(payload.eventType === 'INSERT') {
                    const c = payload.table + '.value.push(' + JSON.stringify(payload.new) + ')'
                    eval(c)
                } else if(payload.eventType === 'UPDATE'){
                    const c = payload.table + '.value[' + payload.table + '.value.findIndex(i => i.id === ' + JSON.stringify(payload.old.id) + ')] = ' + JSON.stringify(payload.new)
                    eval(c)
                }*/
            }
        )
        .subscribe()

    async function createNewItem (dataType,data){
        if(typeOf(data) === 'object') {
            data = {...data, tenant: currentTenant.value}
        } else if(typeOf(data) === 'array') {
            data.map(i => {
                return {
                    ...i,
                    tenant: currentTenant.value
                }
            })
        }



        //console.log(dataType)
        if(dataTypes[dataType].numberRangeHolder) {

            const numberRange = useNumberRange(dataType)
            if(!dataTypes[dataType].numberRangeHolder) {
                data[dataTypes[dataType].numberRangeHolder] = await numberRange.useNextNumber()
            }


        } else if(dataType === "createddocuments") {
            console.log(data.type)
            const numberRange = useNumberRange(data.type)
            data.documentNumber = await numberRange.useNextNumber()

        }

        const {data:supabaseData,error:supabaseError} = await supabase
            .from(dataType)
            .insert(data)
            .select()

        if(supabaseError) {
            console.log(supabaseError)
        } else if (supabaseData) {
            await eval( dataType + '.value.push(' + JSON.stringify(...supabaseData) + ')')
            toast.add({title: `${dataTypes[dataType].labelSingle} hinzugefügt`})
            if(dataTypes[dataType].redirect) await router.push(`/${dataType}/show/${supabaseData[0].id}`)
            return supabaseData
        }
    }

    async function updateItem (dataType, data) {
        const {data:supabaseData,error: supabaseError} = await supabase
            .from(dataType)
            .update(data)
            .eq('id',data.id)
            .select()

        if(supabaseError) {
            console.log(supabaseError)
        } else if(supabaseData) {
            await eval(dataType + '.value[' + dataType + '.value.findIndex(i => i.id === ' + JSON.stringify(data.id) + ')] = ' + JSON.stringify(supabaseData[0]))
            toast.add({title: `${dataTypes[dataType].labelSingle} gespeichert`})
            if(dataTypes[dataType].redirect) await router.push(`/${dataType}/show/${supabaseData[0].id}`)
            return supabaseData
        }
    }

    const uploadFiles = async (formData, files, upsert) => {
        console.log(files)
        console.log(formData)
        let documentsToInsert = []

        const uploadSingleFile = async (file) => {

            const {data, error} = await supabase
                .storage
                .from("files")
                .upload(`${currentTenant.value}/${file.name}`, file, {upsert: upsert})

            if (error) {
                console.log(error)
                console.log(error.statusCode)

                if(error.statusCode === '400') {
                    console.log("is 400")
                    toast.add({title: "Hochladen fehlgeschlagen", description: "Die Datei enthält ungültige Zeichen", icon: "i-heroicons-x-circle", color: "rose", timeout: 10000})
                } else if(error.statusCode === '409') {
                    console.log("is 409")
                    toast.add({title: "Hochladen fehlgeschlagen", description: "Es existiert bereits eine Datei mit diesem Namen", icon: "i-heroicons-x-circle", color: "rose", timeout: 10000})
                } else {
                    toast.add({title: "Hochladen fehlgeschlagen", icon: "i-heroicons-x-circle", color: "rose", timeout: 10000})

                }

            } else if (data) {
                const returnPath = data.path

                documentsToInsert.push({...formData, path: returnPath})
            }

            console.log(data)
        }

        //uploadInProgress.value = true


        if(files.length === 1) {
            await uploadSingleFile(files[0])
        } else if( files.length > 1) {

            for(let i = 0; i < files.length; i++){
                await uploadSingleFile(files[i])
            }

        }

        console.log(documentsToInsert)

        const {data, error} = await supabase
            .from("documents")
            .insert(documentsToInsert)
            .select()
        if(error) console.log(error)
        else {
            console.log(data)

            await fetchDocuments()

            //documents.value.push(...data)
        }
        //uploadModalOpen.value = false;
        //uploadInProgress.value = false;


    }

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

    async function fetchProfiles () {
        profiles.value = (await supabase.from("profiles").select('* , tenants (id, name)')/*.eq("tenant", currentTenant.value)*/.order("fullName")).data
    }
    async function fetchBankAccounts () {
        bankAccounts.value = (await supabase.from("bankaccounts").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchBankStatements () {
        bankStatements.value = (await supabase.from("bankstatements").select().eq('tenant', currentTenant.value).order("date", {ascending:false})).data
    }
    async function fetchEvents () {
        events.value = (await supabase.from("events").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchContracts () {
        contracts.value = (await supabase.from("contracts").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchContacts () {
        contacts.value = (await supabase.from("contacts").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchCustomers () {
        customers.value = (await supabase.from("customers").select().eq('tenant', currentTenant.value).order("customerNumber", {ascending:true})).data
    }
    async function fetchTasks () {
        tasks.value = (await supabase.from("tasks").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchForms () {
        forms.value = (await supabase.from("forms").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchFormSubmits () {
        formSubmits.value = (await supabase.from("formSubmits").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchProducts () {
        products.value = (await supabase.from("products").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchUnits () {
        units.value = (await supabase.from("units").select()).data
    }
    async function fetchProjects () {
        projects.value = (await supabase.from("projects").select().eq("tenant",currentTenant.value)).data
    }
    async function fetchSpaces () {
        spaces.value = (await supabase.from("spaces").select().eq('tenant', currentTenant.value).order("spaceNumber", {ascending:true})).data
    }
    async function fetchMovements () {
        movements.value = (await supabase.from("movements").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchVehicles () {
        vehicles.value = (await supabase.from("vehicles").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchTimes () {
        times.value = (await supabase.from("times").select().eq('tenant', currentTenant.value).order("start", {ascending:false})).data
    }
    async function fetchHistoryItems () {

        historyItems.value = (await supabase.from("historyitems").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchVendors () {
        vendors.value = (await supabase.from("vendors").select().eq('tenant', currentTenant.value).order("vendorNumber", {ascending:true})).data
    }
    async function fetchIncomingInvoices () {
        incominginvoices.value = (await supabase.from("incominginvoices").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchNumberRanges () {
        numberRanges.value = (await supabase.from("numberranges").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchNotifications () {
        notifications.value = (await supabase.from("notifications").select().eq('tenant', currentTenant.value).order("created_at", {ascending: false})).data
    }
    async function fetchAbsenceRequests () {
        absenceRequests.value = (await supabase.from("absencerequests").select().eq('tenant', currentTenant.value)).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 fetchPlants () {
        plants.value = (await supabase.from("plants").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchInventoryItems () {
        inventoryitems.value = (await supabase.from("inventoryitems").select().eq('tenant', currentTenant.value)).data
    }
    async function fetchChats() {
        chats.value = (await supabase.from("chats").select()).data
    }
    async function fetchMessages() {
        messages.value = (await supabase.from("messages").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
    }
    async function fetchCreatedDocuments() {
        createddocuments.value = (await supabase.from("createddocuments").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
    }

    async function fetchWorkingTimes() {
        workingtimes.value = (await supabase.from("workingtimes").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
    }

    async function fetchPhasesTemplates() {
        phasesTemplates.value = (await supabase.from("phasesTemplates").select().eq('tenant', currentTenant.value).order('created_at', {ascending:true})).data
    }

    async function fetchEmailAccounts() {
        emailAccounts.value = (await supabase.from("emailAccounts").select().eq('tenant', currentTenant.value)).data
    }

    async function fetchTextTemplates() {
        texttemplates.value = (await supabase.from("textTemplates").select().eq('tenant', currentTenant.value)).data
    }

    async function fetchServices() {
        services.value = (await supabase.from("services").select().eq('tenant', currentTenant.value)).data
    }

    async function fetchServiceCategories() {
        serviceCategories.value = (await supabase.from("serviceCategories").select().eq('tenant', currentTenant.value)).data
    }

    async function fetchDocuments () {
        let tempDocuments = (await supabase.from("documents").select().eq('tenant', currentTenant.value)).data

        if(tempDocuments.length > 0){
            let paths = []
            tempDocuments.forEach(doc => {
                paths.push(doc.path)
            })

            const {data,error} = await supabase.storage.from('files').createSignedUrls(paths,3600)

            tempDocuments = tempDocuments.map((doc,index) => {

                return {
                    ...doc,
                    url: data[index].signedUrl
                }
            })

            documents.value = tempDocuments
        } else {
            documents.value = []
        }


    }

    async function addHistoryItem(text, user, elementId, resourceType) {
        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 getOwnProfile = computed(()  => {
        return profiles.value.find(i => i.id === user.value.id)

    })

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

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

    const getProjectsByCustomerId = computed(() => (customerId) => {
        return projects.value.filter(item => item.customer === customerId)
    })

    const getPlantsByCustomerId = computed(() => (customerId) => {
        return plants.value.filter(item => item.customer === customerId)
    })

    const getContractsByCustomerId = computed(() => (customerId) => {
        return contracts.value.filter(item => item.customer === customerId)
    })

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

    const getDocumentsByProjectId = computed(() => (projectId) => {
        return documents.value.filter(item => item.project === projectId && !item.tags.includes("Archiviert"))
    })

    const getDocumentsByPlantId = computed(() => (itemId) => {
        return documents.value.filter(item => item.plant === itemId && !item.tags.includes("Archiviert"))
    })

    const getDocumentsByContractId = computed(() => (itemId) => {
        return documents.value.filter(item => item.contract === itemId && !item.tags.includes("Archiviert"))
    })

    const getDocumentsByVehicleId = computed(() => (itemId) => {
        return documents.value.filter(item => item.vehicle === itemId && !item.tags.includes("Archiviert"))
    })

    const getDocumentsByProductId = computed(() => (itemId) => {
        return documents.value.filter(item => item.product === itemId && !item.tags.includes("Archiviert"))
    })

    const getDocumentsByVendorId = computed(() => (itemId) => {
        return documents.value.filter(item => item.vendor === itemId && !item.tags.includes("Archiviert"))
    })

    const getEventsByProjectId = computed(() => (projectId) => {
        return events.value.filter(item => item.project === projectId)
    })

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

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

    const getTasksByPlantId = computed(() => (plantId) => {
        return tasks.value.filter(item => item.plant === plantId)
    })

    const getProjectsByPlantId = computed(() => (plantId) => {
        return projects.value.filter(item => item.plant === plantId)
    })

    const getIncomingInvoicesByVehicleId = computed(() => (vehicleId) => {
        return incominginvoices.value.filter(i => i.accounts.find(a => a.costCentre === vehicleId))
    })

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

    const getMessagesByChatId = computed(() => (chatId) => {
        return messages.value.filter(i => i.destination === chatId)
    })

    const getTextTemplatesByDocumentType = computed(() => (documentType) => {
        return texttemplates.value.filter(i => i.documentType === documentType)
    })

    const getStockByProductId = computed(() => (productId) => {
        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 getMeasures = computed(() => {
        return ownTenant.value.measures
    })

    const getResources = computed(() => {
        return [
            ...profiles.value.filter(i => i.tenant === currentTenant.value).map(profile => {
                return {
                    type: 'Mitarbeiter',
                    title: profile.fullName,
                    id: profile.id
                }
            }),
            ...vehicles.value.map(vehicle => {
                return {
                    type: 'Fahrzeug',
                    title: vehicle.licensePlate,
                    id: `F-${vehicle.id}`
                }
            }),
            ...inventoryitems.value.filter(i=> i.usePlanning).map(item => {
                return {
                    type: 'Inventar',
                    title: item.name,
                    id: `I-${item.id}`
                }
            })
        ]
    })

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

                let title = ""
                if(event.title) {
                    title = event.title
                } else if(event.project) {
                    projects.value.find(i => i.id === event.project) ? projects.value.find(i => i.id === event.project).name : ""
                }

                return {
                    ...event,
                    title: title,
                    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
                }
            })
        ]
    })

    const getEventsByResource = computed(() => {
        let tempEvents = []
        events.value.forEach(event => {
            event.resources.forEach(resource => {
                let eventColor = ownTenant.value.calendarConfig.eventTypes.find(type => type.label === event.type).color

                let title = ""
                if(event.title) {
                    title = event.title
                } else if(event.project) {
                    projects.value.find(i => i.id === event.project) ? projects.value.find(i => i.id === event.project).name : ""
                }



                tempEvents.push({
                    ...event,
                    resourceId: resource.type !== 'Mitarbeiter' ? `${resource.type[0]}-${resource.id}`: resource.id,
                    resourceType: resource.type,
                    title: title,
                    borderColor: eventColor,
                    textColor: eventColor,
                    backgroundColor: "black"
                })


            })
        })



        return [
            ...tempEvents,
            /*...events.value.map(event => {


                let eventColor = ownTenant.value.calendarConfig.eventTypes.find(type => type.label === event.type).color

                return {
                    ...event,
                    title: !event.title ? projects.value.find(i => i.id === event.project).name : event.title,
                    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
                }
            })
        ]
    })

    const getCostCentresComposed = computed(() => {
        return [
            ...vehicles.value.map(vehicle => {
                return {
                    label: "Fahrzeug - " + vehicle.licensePlate,
                    id: vehicle.id
                }
            }),
            ...projects.value.map(project => {
                return {
                    label: "Projekt - " + project.name,
                    id: project.id
                }
            })
        ]
    })


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

    const getServiceById = computed(() => (itemId) => {
        return services.value.find(item => item.id === itemId)
    })

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

    const getIncomingInvoiceById = computed(() => (itemId) => {
        return incominginvoices.value.find(item => item.id === itemId)
    })

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

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

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

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

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

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

    const getTaskById = computed(() => (itemId) => {
        return tasks.value.find(item => item.id === itemId)
    })

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

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

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

    const getPlantById = computed(() => (plantId) => {
        return plants.value.find(item => item.id === plantId)
    })

    const getCreatedDocumentById = computed(() => (documentId) => {
        return createddocuments.value.find(item => item.id === documentId)
    })

    const getInventoryItemById = computed(() => (itemId) => {
        return inventoryitems.value.find(item => item.id === itemId)
    })

    const getProjectById = computed(() => (itemId) => {
        if(projects.value.find(i => i.id === itemId)) {
            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
        } else {
            return null
        }



    })

    return {
        //General
        currentTenant,
        loaded,
        ownTenant,
        initializeData,
        changeTenant,
        uploadFiles,
        hasRight,

        //Data
        profiles,
        events,
        customers,
        tasks,
        projects,
        documents,
        spaces,
        units,
        times,
        products,
        movements,
        forms,
        contracts,
        formSubmits,
        contacts,
        vehicles,
        vendors,
        incominginvoices,
        bankAccounts,
        bankStatements,
        historyItems,
        numberRanges,
        notifications,
        absenceRequests,
        accounts,
        taxTypes,
        plants,
        inventoryitems,
        chats,
        messages,
        createddocuments,
        workingtimes,
        phasesTemplates,
        emailAccounts,
        texttemplates,
        services,
        serviceCategories,
        documentTypesForCreation,

        //Functions
        createNewItem,
        updateItem,
        fetchData,
        clearStore,
        fetchOwnTenant,
        fetchProfiles,
        fetchBankAccounts,
        fetchBankStatements,
        fetchEvents,
        fetchContracts,
        fetchContacts,
        fetchCustomers,
        fetchTasks,
        fetchForms,
        fetchFormSubmits,
        fetchProducts,
        fetchUnits,
        fetchProjects,
        fetchSpaces,
        fetchMovements,
        fetchVehicles,
        fetchTimes,
        fetchHistoryItems,
        fetchVendors,
        fetchIncomingInvoices,
        fetchNumberRanges,
        fetchNotifications,
        fetchDocuments,
        fetchAbsenceRequests,
        fetchPlants,
        fetchInventoryItems,
        fetchChats,
        fetchMessages,
        addHistoryItem,
        //Getters
        getOpenTasksCount,
        getOwnProfile,
        getMovementsBySpace,
        getContactsByCustomerId,
        getProjectsByCustomerId,
        getPlantsByCustomerId,
        getContractsByCustomerId,
        getContactsByVendorId,
        getDocumentsByProjectId,
        getDocumentsByPlantId,
        getDocumentsByContractId,
        getDocumentsByVehicleId,
        getDocumentsByProductId,
        getDocumentsByVendorId,
        getEventsByProjectId,
        getTimesByProjectId,
        getTasksByProjectId,
        getTasksByPlantId,
        getProjectsByPlantId,
        getMovementsBySpaceId,
        getMessagesByChatId,
        getTextTemplatesByDocumentType,
        getStockByProductId,
        getIncomingInvoicesByVehicleId,
        getEventTypes,
        getTimeTypes,
        getDocumentTags,
        getMeasures,
        getResources,
        getEvents,
        getEventsByResource,
        getCostCentresComposed,
        getProductById,
        getServiceById,
        getVendorById,
        getIncomingInvoiceById,
        getContractById,
        getContactById,
        getVehicleById,
        getDocumentById,
        getSpaceById,
        getCustomerById,
        getTaskById,
        getAbsenceRequestById,
        getProjectById,
        getProfileById,
        getAccountById,
        getPlantById,
        getCreatedDocumentById,
        getInventoryItemById,
    }


})