import { defineStore } from 'pinia'

import {
  BUILDING_MATERIAL_OPTIONS,
  INSULATING_MATERIAL_OPTIONS,
  HEATING_INSTALLATION_OPTIONS
} from '@/data/options'
import { 
  calculateCO2Efficiency, 
  calculateFacadeEfficiency, 
  calculateHeatingEfficiency, 
  calculateRoofEfficiency, 
  convertHeatConsumption, 
  ResponseStatus 
} from '@/helpers'
import { buildings as api } from '@/services/api'

export const useBuildingStore = defineStore({
  id: 'buildings',
  state: () => ({
    active: null,
    data: [],
    single: null
  }),
  getters: {
    apartments: (state) => {
      const building = state.data.find(element => element._id === state.active)

      if (building && building.apartments) return building.apartments

      return []
    },
    consumption: (state) => {
      const building = state.single || state.data.find(element => element._id === state.active)

      if (building) {
        const { heatingConsumption, heatingInstallation } = building.data

        return convertHeatConsumption(heatingConsumption, heatingInstallation)
      }

      return null
    },
    current: (state) => state.data.find(element => element._id === state.active) || null,
    firstBuilding: (state) => state.data.length > 0 ? state.data[0] : null,
    insulatedSides: (state) => {
      const building = state.data.find(element => element._id === state.active)

      if (building) {
        const { facadeEast, facadeNorth, facadeSouth, facadeWest } = building.data

        // DEVINFO: Text für die Anzeige der aktuellen Dämmung der einzelnen Gebäudeseiten
        if (facadeEast && facadeNorth && facadeSouth && facadeWest) {
          return 'alle Seiten gedämmt'
        } else if (!facadeEast && !facadeNorth && !facadeSouth && !facadeWest) {
          return 'nicht gedämmt'
        } else {
          return 'teilweise gedämmt'
        }
      }

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

      if (building) {
        const { buildingStructure } = building.data
        const material = BUILDING_MATERIAL_OPTIONS.find(element => element.value === buildingStructure)

        return material ? `${material?.name}` : null
      }

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

      if (building) {
        const { heatingInstallation } = building.data
        const material = HEATING_INSTALLATION_OPTIONS.find(element => element.value === heatingInstallation)

        return material ? `${material?.name}` : null
      }

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

      if (building) {
        const { basementInsulatingMaterial, basementInsulatingMaterialThickness } = building.data
        const material = INSULATING_MATERIAL_OPTIONS.find(element => element.value === basementInsulatingMaterial)

        if (basementInsulatingMaterial && basementInsulatingMaterialThickness) {
          return `${basementInsulatingMaterialThickness} cm ${material.short || material.name}`
        }
      }

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

      if (building) {
        const { facadeInsulatingMaterial, facadeInsulatingMaterialThickness } = building.data
        const material = INSULATING_MATERIAL_OPTIONS.find(element => element.value === facadeInsulatingMaterial)

        if (facadeInsulatingMaterial && facadeInsulatingMaterialThickness) {
          return `${facadeInsulatingMaterialThickness} cm ${material.short || material.name}`
        }
      }

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

      if (building) {
        const { roofInsulatingMaterial, roofInsulatingMaterialThickness } = building.data
        const material = INSULATING_MATERIAL_OPTIONS.find(element => element.value === roofInsulatingMaterial)

        if (roofInsulatingMaterial && roofInsulatingMaterialThickness) {
          return `${roofInsulatingMaterialThickness} cm ${material.short || material.name}`
        }
      }

      return null
    },
    co2Efficiency: (state) => {
      const building = state.single || state.data.find(element => element._id === state.active)

      if (building) {
        const {
          heatingConsumption,
          heatingInstallation
        } = building.data

        if (!heatingInstallation) return null

        const [performance, potential, proportion] = calculateCO2Efficiency(heatingInstallation, heatingConsumption)

        return {
          performance,
          potential: potential > 0 ? potential : null,
          proportion
        }
      }

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

      if (building) {
        const {
          buildingStructure,
          buildingStructureThickness,
          facadeInsulatingMaterial,
          facadeInsulatingMaterialThickness
        } = building.data

        if (!buildingStructure || !buildingStructureThickness || !facadeInsulatingMaterial || !facadeInsulatingMaterialThickness) return null

        const [performance, potential] = calculateFacadeEfficiency(facadeInsulatingMaterial, facadeInsulatingMaterialThickness, buildingStructure, buildingStructureThickness)

        return {
          performance,
          potential
        }
      }

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

      if (building) {
        const { energyPerformanceCertificate, heatingConsumption, heatingInstallation, livingSpace } = building.data
        const consumption = convertHeatConsumption(heatingConsumption, heatingInstallation)

        // eslint-disable-next-line no-unused-vars
        const [distinct, performance, potential] = calculateHeatingEfficiency(energyPerformanceCertificate, consumption, livingSpace)

        if (!performance) return null

        return {
          performance,
          potential
        }
      }

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

      if (building) {
        const {
          flatRoof,
          roofInsulatingMaterial,
          roofInsulatingMaterialThickness,
        } = building.data

        if (!roofInsulatingMaterial || !roofInsulatingMaterialThickness) return null

        const [performance, potential] = calculateRoofEfficiency(flatRoof, roofInsulatingMaterial, roofInsulatingMaterialThickness)

        return {
          performance,
          potential,
        }
      }

      return null
    },
  },
  actions: {
    async createBuilding(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 fetchBuildingById(id) {
      try {
        const response = await api.findOne(id)

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

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

        return { success: false, message: response.code }
      } catch (error) {
        return { success: false }
      }
    },
    async fetchBuildings() {
      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 }
      }
    },
    setActiveBuilding(id) {
      this.active = id
    },
    setBuildings(data) {
      this.data = data
    },
    async updateBuilding(id, data) {
      try {
        const response = await api.update(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 updateBuildingCharacteristics(id, data) {
      try {
        const response = await api.updateCharacteristics(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 updateBuildingHeating(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 updateBuildingFacade(id, data) {
      try {
        const response = await api.updateFacade(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 updateBuildingRoof(id, data) {
      try {
        const response = await api.updateRoof(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 updateBuildingBasement(id, data) {
      try {
        const response = await api.updateBasement(id, data)

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

        return { success: false, message: response.code }
      } catch (error) {
        return { success: false }
      }
    }
  }
})