apartments.js

import { defineStore } from 'pinia'

import {
  WINDOW_CONDITION_OPTIONS,
  WINDOW_FRAME_OPTIONS,
  WINDOW_GLAZING_OPTIONS
} from '@/data/options'
import {
  calculateCO2Efficiency,
  calculateHeaterEfficiency,
  calculateHeatingEfficiency,
  calculateWindowEfficiency,
  ResponseStatus
} from '@/helpers'
import { apartments as api } from '@/services/api'
import { useBuildingStore } from '@/stores/buildings'
import { useUserStore } from '@/stores/users'

export const useApartmentStore = defineStore({
  id: 'apartments',
  state: () => ({
    active: null,
    data: [],
    files: {}
  }),
  getters: {
    current: (state) => state.data.find(element => element._id === state.active),
    count: (state) => state.data.length,
    ofBuilding: (state) => {
      const buildingStore = useBuildingStore()

      return state.data.filter(element => element.linkedTo === buildingStore.active)
    },
    owner: (state) => {
      const userStore = useUserStore()
      const apartments = state.data.find(element => element._id === state.active)

      if (apartments) {
        return userStore.data.find(element => element._id === apartments.owner)
      }
    },
    windowFrameString: (state) => {
      const apartments = state.data.find(element => element._id === state.active)

      if (apartments) {
        const { windowFrame } = apartments.data
        const material = WINDOW_FRAME_OPTIONS.find(element => element.value === windowFrame)

        return material ? material.name : null
      }

      return null
    },
    windowConditionString: (state) => {
      const apartments = state.data.find(element => element._id === state.active)

      if (apartments) {
        const { averageWindowCondition } = apartments.data
        const material = WINDOW_CONDITION_OPTIONS.find(element => element.value === averageWindowCondition)

        return material ? material.name : null
      }

      return null
    },
    windowGlazingString: (state) => {
      const apartments = state.data.find(element => element._id === state.active)

      if (apartments) {
        const { windowGlazing } = apartments.data
        const material = WINDOW_GLAZING_OPTIONS.find(element => element.value === windowGlazing)

        return material ? material.name : null
      }

      return null
    },
    summary: (state) => {
      const buildingStore = useBuildingStore()
      const apartments = state.data.filter(element => element.linkedTo === buildingStore.active)

      if (apartments) {
        let totalArea = null
        let totalHeatingElements = null
        let totalPanelheating = null
        let totalWindows = null

        apartments.forEach((element) => {
          const {
            area,
            largeHeatingElements,
            largeWindows,
            mediumHeatingElements,
            mediumWindows,
            panelHeating,
            roofWindows,
            smallHeatingElements,
            smallWindows,
          } = element.data

          totalArea += area
          totalHeatingElements += largeHeatingElements + mediumHeatingElements + smallHeatingElements
          totalPanelheating += panelHeating
          totalWindows += largeWindows + mediumWindows + roofWindows + smallWindows
        })

        return {
          area: totalArea,
          apartments: apartments.length,
          heatingElements: totalHeatingElements,
          panelHeating: totalPanelheating,
          windows: totalWindows
        }
      }

      return {}
    },
    co2Efficiency: (state) => {
      const apartment = state.data.find(element => element._id === state.active)

      if (apartment) {
        const { heatDemand, heatingType } = apartment.data

        if (!heatingType) {
          return null
        }

        const [performance, potential, proportion] = calculateCO2Efficiency(heatingType, heatDemand)

        return {
          delta: performance,
          km: proportion,
          potential
        }
      }

      return null
    },
    heaterEfficiency: (state) => {
      const buildingStore = useBuildingStore()
      const building = state.data.filter(element => element.linkedTo === buildingStore.active)
      const apartment = state.data.find(element => element._id === state.active)

      if (building && apartment) {
        const { largeHeatingElements, mediumHeatingElements, smallHeatingElements, workingHeatingInstallations } = apartment.data

        let sum = largeHeatingElements + mediumHeatingElements + smallHeatingElements
        if (sum === 0) return null

        let [performance] = calculateHeaterEfficiency(sum, workingHeatingInstallations)

        return {
          delta: performance
        }
      }

      return null
    },
    heatingEfficiency: (state) => {
      const buildingStore = useBuildingStore()
      const building = buildingStore.single
      const apartment = state.data.find(element => element._id === state.active)

      if (building && apartment) {
        const [distict, performance, potential] = calculateHeatingEfficiency(building.data.energyPerformanceCertificate, buildingStore.consumption, building.data.livingSpace, apartment.data.heatDemand, apartment.data.area)

        if (!performance) return null

        return {
          distict,
          performance: Math.round(performance),
          potential: Math.round(potential)
        }
      }

      return null
    },
    windowEfficiency: (state) => {
      const buildingStore = useBuildingStore()
      const building = state.data.filter(element => element.linkedTo === buildingStore.active)
      const apartment = state.data.find(element => element._id === state.active)

      if (building && apartment) {
        const { averageWindowAge, averageWindowCondition, windowGlazing } = apartment.data

        if (!averageWindowAge && !averageWindowCondition && !windowGlazing) {
          return null
        }

        const [performance] = calculateWindowEfficiency(averageWindowAge, averageWindowCondition, windowGlazing)

        return {
          performance
        }
      }

      return null
    }
  },
  actions: {
    async createApartment(data) {
      try {
        const response = await api.create(data)

        if (response.status === ResponseStatus.Success) {
          return { success: true, message: response.code }
        }

        return { success: false, message: response.code }
      } catch (error) {
        return { success: false }
      }
    },
    async fetchApartments() {
      try {
        const response = await api.findAll()

        if (response.status === ResponseStatus.Success) {
          this.data = response.data

          return { success: true, message: response.code }
        }

        return { success: false, message: response.code }
      } catch (error) {
        return { success: false }
      }
    },
    async fetchFile(id) {
      try {
        const blob = await api.findFile(id)

        if (blob && blob.size > 0) {
          const url = URL.createObjectURL(blob)
          this.files[id] = url

          return { success: true }
        }

        return { success: false }
      } catch (error) {
        return { success: false }
      }
    },
    setActiveApartment(id) {
      this.active = id
    },
    setApartments(data) {
      this.data = data
    },
    async updateApartmentHeating(id, data) {
      try {
        const response = await api.updateHeating(id, data)

        if (response.status === ResponseStatus.Success) {
          return { success: true, message: response.code }
        }

        return { success: false, message: response.code }
      } catch (error) {
        return { success: false }
      }
    },
    async updateApartmentWindows(id, data) {
      try {
        const response = await api.updateWindows(id, data)

        if (response.status === ResponseStatus.Success) {
          return { success: true, message: response.code }
        }

        return { success: false, message: response.code }
      } catch (error) {
        return { success: false }
      }
    },
    async uploadFile(id, data) {
      try {
        const response = await api.uploadFile(id, data)

        if (response.status === ResponseStatus.Success) {
          return { success: true }
        }

        return { success: false }
      } catch (error) {
        return { success: false }
      }
    }
  }
})