/* eslint-disable no-console */
import output from '@/output'
import {
  getAddAbilityTasks,
  getAddCommandInitialAnswer,
  getAddModuleTasks,
  validateAddCommandTargetingType,
  validateProjectCanExecuteAddCommand,
} from '@/scripts'
import type { AddCommandInitialAnswer, TargetType } from '@/scripts'
import { getAddEventTasks } from '@/scripts/add/event'
import { getPluginConfigContent, createUpgradeMessage } from '@/scripts/shared'
import type { AddCLIOptionsSchema, ProjectPluginConfig } from '@ones-open/cli-utils'
import Listr from 'listr'
import type { ListrTask } from 'listr'

import { cwd, exit } from 'process'

async function runPreRequireTask(rawTargetStr: string, options: AddCLIOptionsSchema) {
  const rawInputParams = { target: rawTargetStr, ...options }
  const preRequireTaskList: ListrTask<{
    initialAnswers: AddCommandInitialAnswer
    pluginConfigContent: ProjectPluginConfig
  }>[] = [
    {
      title: 'Validating the input params',
      task: () => validateAddCommandTargetingType(rawInputParams),
    },
    {
      title: 'Validating project files exists',
      task: () => validateProjectCanExecuteAddCommand(),
    },
    {
      title: 'Generating initial answers by input params',
      task: async (ctx) => {
        ctx.initialAnswers = await getAddCommandInitialAnswer(rawInputParams)
      },
    },
    {
      title: 'Parsing plugin config content',
      task: async (ctx) => {
        ctx.pluginConfigContent = await getPluginConfigContent()
      },
    },
  ]
  const preRequireTasks = new Listr(preRequireTaskList)

  return preRequireTasks.run()
}

async function getTargetTasks(
  initialAnswer: AddCommandInitialAnswer,
  pluginConfigContent: ProjectPluginConfig,
  currentWorkingDirectory = cwd(),
) {
  const { target } = initialAnswer

  const isAddingAbility = (target: TargetType): target is 'ability' => target === 'ability'
  const isAddingEvent = (target: TargetType): target is 'event' => target === 'event'

  if (isAddingAbility(target)) {
    return getAddAbilityTasks({ initialAnswer, pluginConfigContent, currentWorkingDirectory })
  }

  if (isAddingEvent(target)) {
    return getAddEventTasks({ initialAnswer, pluginConfigContent, currentWorkingDirectory })
  }

  return getAddModuleTasks({
    initialAnswer,
    pluginConfigContent,
    currentWorkingDirectory,
  })
}

async function executeTargetTask(targetTasks: ListrTask[]) {
  const addTasks = new Listr(targetTasks)
  return addTasks.run()
}

async function add(rawTargetStr: string, options: AddCLIOptionsSchema) {
  let pluginConfigContent: ProjectPluginConfig
  let addCommandInitialAnswers: AddCommandInitialAnswer
  let targetTasks

  try {
    const preRequireTaskResult = await runPreRequireTask(rawTargetStr, options)
    pluginConfigContent = preRequireTaskResult.pluginConfigContent
    addCommandInitialAnswers = preRequireTaskResult.initialAnswers
    output.newline()
    output.completed('Run pre-require tasks')
  } catch (error) {
    output.error(error)
    exit(1)
  }

  try {
    targetTasks = await getTargetTasks(addCommandInitialAnswers, pluginConfigContent)
  } catch (error) {
    output.error(error)
    exit(1)
  }

  try {
    if (!targetTasks) throw new Error('Target tasks is not defined')

    await executeTargetTask(targetTasks)
    const upgradeMessage = await createUpgradeMessage()

    output.newline()
    output.success(`Add ${addCommandInitialAnswers.target}`)
    upgradeMessage && output.warn(upgradeMessage)
  } catch (error) {
    output.error(error, `Execute add ${addCommandInitialAnswers.target} action`)
  }
}

export { add }