import { validationResult } from 'express-validator'

import { Building, User } from '../db/index.js'
import { getUserFromRequest, success, warning } from '../helpers/index.js'
import { hashString } from '../utils/crypto.js'

import { ResponseCode } from '../ENUMS.js'

export const createApartment = async (req, res) => {
  const validationErrors = validationResult(req)

  if (!validationErrors.isEmpty()) {
    return warning(res, { code: ResponseCode.ValidationError })
  }

  const { accessor } = getUserFromRequest(req)
  const { apartmentName, buildingId, password, username } = req.body

  const building = await Building.findOne({ _id: buildingId })

  if (building) {
    if (building.prefix) {
      const result = await User.createBuildingUser(accessor, {
        username: `${building.prefix}_${username}`,
        encryptedPassword: hashString(password),
        role: 'user',
        createdBy: accessor,
        linkedTo: building._id
      })

      if (result) {
        await building.apartments.push({
          name: apartmentName,
          linkedTo: building._id,
          owner: result._id
        })

        await building.save()

        return success(res, { code: ResponseCode.Created, id: result._id }, 201)
      }
    }

    return warning(res, { code: ResponseCode.InvalidInput })
  }

  warning(res, { code: ResponseCode.InvalidInput })
}

export const getApartment = async (req, res) => {
  const validationErrors = validationResult(req)

  if (!validationErrors.isEmpty()) {
    return warning(res, { code: ResponseCode.ValidationError })
  }

  const { accessor, role } = getUserFromRequest(req)
  const { id } = req.params

  let result

  if (role === 'administrator') {
    result = await Building.findOne({
      owner: accessor,
      'apartments._id': id
    })
      .select('apartments._id apartments.name apartments.data apartments.linkedTo apartments.image apartments.owner')
  } else {
    result = await Building.findOne({
      'apartments.owner': accessor,
      'apartments._id': id
    })
      .select('apartments._id apartments.name apartments.data apartments.linkedTo apartments.image')
  }

  if (result) {
    return success(res, { data: result.apartments.length > 0 ? result.apartments[0] : null })
  }

  warning(res, { code: ResponseCode.NotFound, data: null }, 404)
}

export const getApartments = async (req, res) => {
  const { accessor, role } = getUserFromRequest(req)

  if (role === 'administrator') {
    const result = await Building.find({ owner: accessor }).select('apartments._id apartments.name apartments.data apartments.linkedTo apartments.owner')

    success(res, { data: result?.map(item => item.apartments).flat() })

    return
  }

  const result = await Building.findOne({ 'apartments.owner': accessor }, 'apartments.$')

  if (result) {
    return success(res, { data: result.apartments })
  }

  warning(res, { code: ResponseCode.NotFound, data: [] })
}

export const getFile = async (req, res) => {
  const { id } = req.params

  const result = await Building.findOne({ 'apartments._id': id }, 'apartments.$')

  if (result) {
    return res.send(result.apartments[0].image.buffer.data)
  }

  warning(res, { code: ResponseCode.NotFound })
}

export const updateFiles = async (req, res) => {
  const { accessor } = getUserFromRequest(req)
  const { id } = req.params
  const image = req.file

  const result = await Building.findOneAndUpdate({
    owner: accessor,
    'apartments._id': id
  }, {
    $set: {
      'apartments.$.image': {
        name: '',
        originalName: image.originalname,
        mimeType: image.mimetype,
        buffer: {
          data: image.buffer,
          contentType: image.mimeType
        },
        updatedAt: Date.now()
      }
    }
  }, { new: true, runValidators: true }).select('apartments._id')

  success(res, { code: ResponseCode.UpdateSuccess, data: result })
}

export const updateHeatingData = async (req, res) => {
  const validationErrors = validationResult(req)

  if (!validationErrors.isEmpty()) {
    return warning(res, { code: ResponseCode.ValidationError })
  }

  const { accessor } = getUserFromRequest(req)
  const { id } = req.params
  const {
    apartmentComment,
    area,
    ceilingHeight,
    centralHeating,
    heatDemand,
    heatingType,
    largeHeatingElements,
    mediumHeatingElements,
    smallHeatingElements,
    panelHeating,
    powerDemand,
    workingHeatingInstallations
  } = req.body

  const building = await Building.findOne({ 'apartments.owner': accessor, 'apartments._id': id }).select('apartments')

  if (building === null || building.apartments.length === 0) {
    return warning(res, { code: ResponseCode.NotFound })
  }

  const result = await Building.findOneAndUpdate({
    'apartments._id': id
  }, {
    $set: {
      updatedAt: Date.now(),
      'apartments.$.data.apartmentComment': apartmentComment,
      'apartments.$.data.area': area,
      'apartments.$.data.ceilingHeight': ceilingHeight,
      'apartments.$.data.centralHeating': centralHeating,
      'apartments.$.data.heatDemand': heatDemand,
      'apartments.$.data.heatingType': heatingType,
      'apartments.$.data.largeHeatingElements': largeHeatingElements,
      'apartments.$.data.mediumHeatingElements': mediumHeatingElements,
      'apartments.$.data.smallHeatingElements': smallHeatingElements,
      'apartments.$.data.panelHeating': panelHeating,
      'apartments.$.data.powerDemand': powerDemand,
      'apartments.$.data.workingHeatingInstallations': workingHeatingInstallations
    }
  }, { new: true, runValidators: true })
    .select([
      'apartments.data.apartmentComment',
      'apartments.data.area',
      'apartments.data.ceilingHeight',
      'apartments.data.centralHeating',
      'apartments.data.heatDemand',
      'apartments.data.heatingType',
      'apartments.data.largeHeatingElements',
      'apartments.data.mediumHeatingElements',
      'apartments.data.smallHeatingElements',
      'apartments.data.panelHeating',
      'apartments.data.powerDemand',
      'apartments.data.workingHeatingInstallations'
    ])

  if (result) {
    if (result.apartments.length === 0) {
      return warning(res, { code: ResponseCode.NotFound })
    }

    return success(res, {
      code: ResponseCode.UpdateSuccess,
      data: null
    })
  }

  warning(res, { code: ResponseCode.NotFound })
}

export const updateWindowData = async (req, res) => {
  const validationErrors = validationResult(req)

  if (!validationErrors.isEmpty()) {
    return warning(res, { code: ResponseCode.ValidationError })
  }

  const { accessor } = getUserFromRequest(req)
  const { id } = req.params
  const { averageWindowAge, averageWindowCondition, largeWindows, mediumWindows, roofWindows, smallWindows, windowComment, windowFrame, windowGlazing } = req.body

  const building = await Building.findOne({ 'apartments.owner': accessor, 'apartments._id': id }).select('apartments')

  if (building === null || building.apartments.length === 0) {
    return warning(res, { code: ResponseCode.NotFound })
  }

  const result = await Building.findOneAndUpdate({
    'apartments._id': id
  }, {
    $set: {
      updatedAt: Date.now(),
      'apartments.$.data.averageWindowAge': averageWindowAge,
      'apartments.$.data.averageWindowCondition': averageWindowCondition,
      'apartments.$.data.largeWindows': largeWindows,
      'apartments.$.data.mediumWindows': mediumWindows,
      'apartments.$.data.roofWindows': roofWindows,
      'apartments.$.data.smallWindows': smallWindows,
      'apartments.$.data.windowComment': windowComment,
      'apartments.$.data.windowFrame': windowFrame,
      'apartments.$.data.windowGlazing': windowGlazing
    }
  }, { new: true, runValidators: true })
    .select([
      'apartments.data.averageWindowAge',
      'apartments.data.averageWindowCondition',
      'apartments.data.largeWindows',
      'apartments.data.mediumWindows',
      'apartments.data.roofWindows',
      'apartments.data.smallWindows',
      'apartments.data.windowComment',
      'apartments.data.windowFrame',
      'apartments.data.windowGlazing'
    ])

  if (result) {
    if (result.apartments.length === 0) {
      return warning(res, { code: ResponseCode.NotFound })
    }

    return success(res, {
      code: ResponseCode.UpdateSuccess,
      data: null
    })
  }

  warning(res, { code: ResponseCode.NotFound })
}