import moment from 'moment'
import * as ManagingCompanyController from '../../../controllers/managingCompany'
import * as ProjectController from '../../../controllers/project'
import { prismaClient as prisma } from '../../../prismaClient'
import { condoManagerLogger } from '../../logger'
import * as FtpHelpers from './ftp'
import * as ftp from 'ftp'

const Client = ftp.default

export default async function createMissingManagingCompaniesAndProjects() {
  const connection = new Client()
  await FtpHelpers.connect(connection)
  condoManagerLogger.info('Creating managing companies and missing projects')

  const managingCompaniesDirectories = await FtpHelpers.getListForCurrentPath(connection)
  await managingCompaniesDirectories.reduce(async (promise, managingCompanyDirectory) => {
    await promise

    const condoManagerIdForManagingCompany = managingCompanyDirectory.name.replace('Commun', '')

    condoManagerLogger.info(`♻️  Processing folder ${managingCompanyDirectory.name}`)

    let managingCompany = (
      await prisma.managingCompany.findMany({
        take: 1,
        where: { condoManagerId: condoManagerIdForManagingCompany },
        select: {
          id: true,
          condoManagerApiKey: true,
          shortName: true,
          projects: {
            select: {
              id: true,
              condoManagerId: true,
              name: true,
            },
          },
        },
      })
    )[0]

    if (
      managingCompanyDirectory.name === 'Commun4006' || // Gestactif
      managingCompanyDirectory.name === 'Commun4027' // Group homana
    ) {
      return condoManagerLogger.info(`Don't process ${managingCompanyDirectory.name}`)
    }

    if (!managingCompany) {
      condoManagerLogger.error(
        `❌ No managing company found for ${condoManagerIdForManagingCompany}`
      )
      // Make sure we have at least one project to get the managing company informations
      const createdManagingCompany = await ManagingCompanyController.createManagingCompany({
        data: {
          condoManagerId: condoManagerIdForManagingCompany,
          shortName: 'Managing company ABC',
        },
      })
      managingCompany = await prisma.managingCompany.findOne({
        where: { id: createdManagingCompany.id },
        select: {
          id: true,
          condoManagerApiKey: true,
          shortName: true,
          projects: {
            select: {
              id: true,
              condoManagerId: true,
              name: true,
            },
          },
        },
      })
    }

    if (managingCompany.condoManagerApiKey) {
      return condoManagerLogger.info(
        `Don't process ${managingCompany.shortName} because they have API KEY`
      )
    }

    // Since the company has api key, we don't want to create project here
    if (managingCompany.condoManagerApiKey) {
      return
    }

    condoManagerLogger.info(`♻️  Checking ${managingCompany.shortName} folder`)

    await FtpHelpers.changeDir(connection, managingCompanyDirectory.name)

    const listOfProjectDirectoriesForCurrentManagingCompany = await FtpHelpers.getListForCurrentPath(
      connection
    )

    // Check if the last push was made in the past 24 hours
    listOfProjectDirectoriesForCurrentManagingCompany.forEach(async (projectDirectory) => {
      try {
        const walterProject = managingCompany.projects.find(
          (p) => p.condoManagerId && p.condoManagerId === projectDirectory.name.replace('Ass', '')
        )
        if (walterProject) {
          await prisma.project.update({
            where: { id: walterProject.id },
            data: { lastCondoManagerDataPushDate: moment(projectDirectory.date).toDate() },
          })
        }
      } catch (error) {
        condoManagerLogger.error(error)
      }
    })

    // Get unexsintg projcet in Walter so we can create them
    let unexistingProjectsDirectories = listOfProjectDirectoriesForCurrentManagingCompany.filter(
      (projectDirectory) => {
        if (!projectDirectory.name.startsWith('Ass')) {
          return false
        }
        if (
          managingCompany.projects.some(
            (project) => project.condoManagerId === projectDirectory.name.replace('Ass', '')
          )
        ) {
          return false
        }

        return true
      }
    )

    // Don't add tom condo in corev
    if (managingCompanyDirectory.name === 'Commun4002') {
      unexistingProjectsDirectories = unexistingProjectsDirectories.filter(
        (projectDirectory) => !projectDirectory.name.includes('10020')
      )
    }

    await unexistingProjectsDirectories.reduce(async (promise, projectDirectory) => {
      await promise
      await ProjectController.createProject({
        managingCompanyId: managingCompany.id,
        data: {
          name: projectDirectory.name,
          condoManagerId: projectDirectory.name.replace('Ass', ''),
          building: {
            create: {
              address: {
                create: {
                  address1: '123 TEST ADDRESS',
                },
              },
            },
          },
        },
      })
    }, Promise.resolve)

    if (unexistingProjectsDirectories.length) {
      condoManagerLogger.info(
        `${unexistingProjectsDirectories.length} new projects created for ${managingCompany.shortName}`
      )
    }

    await FtpHelpers.moveUpDir(connection)
  }, Promise.resolve)

  condoManagerLogger.info('Done creating managing companies and missing projects')
  connection.end()
}