import { config } from './config.mjs'
import { mkdir, readFile, writeFile, copyFile } from 'node:fs/promises'
import { join, dirname } from 'path'
import mustache from 'mustache'
import rdir from 'recursive-readdir'
import chalk from 'chalk'
import prompts from 'prompts'
import { oraPromise } from 'ora'
import { execa } from 'execa'
import axios from 'axios'
import { fileURLToPath } from 'url'

// Current working directory
let cwd
try {
  cwd = __dirname
} catch {
  cwd = dirname(fileURLToPath(import.meta.url))
}

const nl = '\n'
const tab = '  '
const nlt = nl + tab

// Checks for node 16 or higher
export const checkNodeVersion = () => {
  const node_version = process.version.slice(1).split('.')[0]
  if (parseInt(node_version) < config.node) {
    console.log(
      chalk.yellow(nlt + `⚠️  FreeSewing requires Node v${config.node} or newer`) +
        nl +
        nlt +
        'We hightly recommend using NVM to manage your Node versions:' +
        nlt +
        chalk.blue('https://github.com/nvm-sh/nvm') +
        nl +
        nlt +
        'When in doubt, pick an active LTS version:' +
        nlt +
        chalk.blue('https://nodejs.org/en/about/releases/') +
        nl +
        nl
    )
    process.exit(1)
  }
}

// Helper method to validate the design name
const validateDesignName = (name) => {
  if (/^([a-z]+)$/.test(name)) return true
  else return ' 🙈 Please use only [a-z], no spaces, no capitals, no nothing 🤷'
}

// Gets user input to figure out what to do
export const getChoices = async () => {
  const { template } = await prompts({
    type: 'select',
    name: 'template',
    message: 'What template would you like to use? 📑',
    choices: [
      { title: 'Tutorial', value: 'tutorial', description: 'Setup the pattern design tutorial' },
      { title: 'From Scratch', value: 'scratch', description: 'Create a design from scratch' },
      {
        title: 'Extend Brian',
        value: 'brian',
        description: 'Extend the Brian design (basic torso block for menswear)',
      },
      {
        title: 'Extend Bent',
        value: 'bent',
        description: 'Extend the Bent design (like brian with added two-part sleeve)',
      },
      {
        title: 'Extend Bella',
        value: 'bella',
        description: 'Extend the Bella design (womenswear torso block)',
      },
      {
        title: 'Extend Breanna',
        value: 'breanna',
        description: 'Extend the Breanna design (womenswear torso block - YMMV)',
      },
      {
        title: 'Extend Titan',
        value: 'titan',
        description: 'Extend the Titan design (gender-neutral trouser block)',
      },
    ],
    initial: 0,
  })

  const { name } =
    template === 'tutorial'
      ? { name: 'tutorial' }
      : await prompts({
          type: 'text',
          name: 'name',
          message: 'What name would you like the design to have? 🏷️ ([a-z] only)',
          validate: validateDesignName,
        })

  const { manager } = await prompts({
    type: 'select',
    name: 'manager',
    message: 'What package manager should we use? 📦',
    choices: [
      { title: 'yarn', value: 'yarn', description: 'Yarn - Nice if you have it' },
      { title: 'npm', value: 'npm', description: 'NPM - Comes with NodeJS' },
    ],
    initial: 0,
  })

  return { template, name, manager }
}

// Keep track of directories that need to be created
const dirs = {}
const ensureDir = async (file, suppress = false) => {
  const dir = suppress ? dirname(file.replace(suppress)) : dirname(file)
  if (!dirs[dir]) {
    await mkdir(dir, { recursive: true })
    dirs[dir] = true
  }
}

/** ensure a template file has a directory, then use mustache to render and save it */
const writeTemplateFile = async (to, template, args) => {
  if (!dirs[to]) await ensureDir(to)

  return writeFile(to, mustache.render(template, args))
}

// Helper method to copy template files
const copyTemplate = async (config, choices) => {
  // Copy files in parallel rather than using await
  const promises = []

  // const templateConfig
  // Copy shared files
  for (const from of config.files.shared) {
    // FIXME: Explain the -7
    const to = join(config.dest, from.slice(config.source.shared.length - 7))
    if (!dirs[to]) await ensureDir(to)
    promises.push(copyFile(from, to))
  }

  // Template the package.json
  const packageJsonTemplate = await readFile(config.files.templates['package.json'], 'utf-8')
  const packageJsonTo = join(config.dest, 'package.json')
  promises.push(
    writeTemplateFile(packageJsonTo, packageJsonTemplate, {
      name: choices.name,
      tag: config.tag,
      dependencies: config.templateData.dependencies,
    })
  )

  // design files go here
  const designSrcDir = join(config.dest, 'design/src')

  // Template the index file
  const indexTemplate = await readFile(config.files.templates['index'], 'utf-8')
  const indexTo = join(designSrcDir, 'index.mjs')

  // does this base have parts with a lot of attending config?
  const complexParts = typeof config.templateData.parts[0] === 'object'
  // get the part names based on how they are given in the configuration
  const partNames = complexParts
    ? config.templateData.parts.map((p) => p.part)
    : config.templateData.parts
  // write the file
  promises.push(
    writeTemplateFile(indexTo, indexTemplate, {
      name: choices.name,
      parts: partNames,
    })
  )

  // Template the parts
  const partTemplate = await readFile(config.files.templates.part, 'utf-8')
  // does this design inherit from another?
  const doesInherit = !config.templateData.noInheritance

  // all part templates need these arguments
  const baseConfig = {
    name: choices.name, // the name of the design
    doesInherit, // whether it's an inherited design
    draftUses: {}, // what parameters need to be uncommented in the draft method (default none because part is always uncommented)
  }

  // if it inherits, we also need the name of the design it inherits from
  if (doesInherit) {
    baseConfig.baseName = choices.template
    baseConfig.baseNameUpcase = choices.template[0].toUpperCase() + choices.template.slice(1)
  }

  // for each part
  config.templateData.parts.forEach((p) => {
    // set up the arguments based on what's in the part's config
    const templateArgs = complexParts
      ? {
          ...baseConfig,
          part: p,
        }
      : {
          ...baseConfig,
          ...p,
        }

    // add an uppercase version of the partName
    templateArgs.partUpcase = templateArgs.part[0].toUpperCase() + templateArgs.part.slice(1)

    // write the part file
    const to = join(designSrcDir, `${templateArgs.part}.mjs`)
    promises.push(writeTemplateFile(to, partTemplate, templateArgs))
  })

  await Promise.all(promises)

  return
}

// Helper method to run [yarn|npm] install
const installDependencies = async (config, choices) =>
  await execa(`${choices.manager} install`, {
    cwd: config.dest,
    shell: true,
  })

// Helper method to download web environment
const downloadLabFiles = async (config) => {
  const promises = []
  for (const dir in config.fetch) {
    for (const file of config.fetch[dir]) {
      const to = typeof file === 'string' ? join(config.dest, file) : join(config.dest, file.to)
      if (!dirs[to]) await ensureDir(to)
      promises.push(
        axios
          .get(
            `${config.fileUri}/${config.repo}/${config.branch}/${dir}/${
              typeof file === 'string' ? file : file.from
            }`
          )
          .catch((err) => console.log(err))
          .then((res) => promises.push(writeFile(to, res.data)))
      )
    }
  }

  await Promise.all(promises)

  return
}

// Helper method to initialize a git repository
const initGitRepo = async (config, choices) => {
  await writeFile(join(config.dest, '.gitignore'), config.gitignore, 'utf-8')

  return execa(
    `git init -b main && git add . && git commit -m ":tada: Initialized ${choices.name} repository"`,
    {
      cwd: config.dest,
      shell: true,
    }
  )
}

// Tips
const showTips = (config, choices) => {
  console.log(`
  All done 🤓 Your new design ${chalk.yellow.bold(
    choices.name
  )} was initialized in: ${chalk.green.bold(config.dest)}

  The code for your design is in the ${chalk.yellow.bold('design')} folder.
  The other files and folders are the development environment. You can safely ignore those.

  To start your development environment, follow these three steps:

    1) Start by entering the directory: ${chalk.blue.bold('cd ' + config.dest)}
    2) Then run this command: ${chalk.blue.bold(
      choices.manager === 'yarn' ? 'yarn dev' : 'npm run dev'
    )}
    3) Now open your browser and navigate to ${chalk.green('http://localhost:8000/')}

  ${chalk.bold.yellow('🤔 More info & help')}
  ${chalk.gray('≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡')}`)

  if (choices.template === 'tutorial')
    console.log(`
  Our pattern design tutorial is available at: ${chalk.green(
    'https://freesewing.dev/tutorials/pattern-design'
  )}

  It will walk your through the process step by step.
  If you get stuck, reach out to our community on Discord: ${chalk.green(
    'https://discord.freesewing.dev/'
  )}
  The ${chalk.bold('development-help')} channel is a good place to ask questions

  Don't be shy to reach out. If something is not clear, that's on us, not on you.
  So your feedback really helps us improve our tutorial/documentation.

  Thanks for giving FreeSewing a shot. We hope you'll 💜 it.

  Have fun 🤓
  `)
  else
    console.log(`

  FreeSewing's documentation for developers is available at: ${chalk.green(
    'https://freesewing.dev/'
  )}

  Our community is on Discord: ${chalk.green('https://discord.freesewing.dev/')}
  The ${chalk.bold('development-help')} channel is a good place to ask for help if you get stuck

  Happy hacking 🤓
  `)
}

// Creates the environment based on the user's choices
export const createEnvironment = async (choices) => {
  // Store directories for re-use
  ;(config.cwd = cwd),
    (config.source = {
      root: cwd,
      templateData: cwd + `/../templates/from-${choices.template}.mjs`,
      templates: join(cwd, `/../templates/shared`),
      shared: cwd + `/../shared`,
    })
  config.dest = join(process.cwd(), choices.name)

  // Create target directory
  await mkdir(config.dest, { recursive: true })

  const templateFiles = await rdir(config.source.templates)
  const templates = {}
  templateFiles.forEach(
    (f) =>
      (templates[f.replace(`${config.source.templates}/`, '').replace(/(\.mjs)*\.mustache/, '')] =
        f)
  )

  // Find files
  config.files = {
    templates,
    shared: await rdir(config.source.shared),
  }

  config.templateData = await import(config.source.templateData)

  // Output a linebreak
  console.log()

  // Copy/Template files
  try {
    await oraPromise(copyTemplate(config, choices), {
      text:
        chalk.white.bold('🟨⬜⬜⬜  Copying template files') +
        chalk.white.dim('   |  Just a moment'),
      successText: chalk.white.bold('🟩⬜⬜⬜  Copied template files'),
      failText: chalk.white.bold(
        '🟥⬜⬜⬜  Failed to copy template files  |  Development environment will not function'
      ),
    })
  } catch (err) {
    console.log(err)
  }

  // Install dependencies
  try {
    await oraPromise(installDependencies(config, choices), {
      text:
        chalk.white.bold('🟩🟨⬜⬜  Installing dependencies') +
        chalk.white.dim('  |  Please wait, this will take a while'),
      successText: chalk.white.bold('🟩🟩⬜⬜  Installed dependencies'),
      failText: chalk.white.bold(
        '🟩🟥⬜⬜  Failed to install dependencies  |  Development environment will not function'
      ),
    })
  } catch (err) {
    /* no feedback here */
  }

  // Fetch web components
  try {
    await oraPromise(downloadLabFiles(config), {
      text:
        chalk.white.bold('🟩🟩🟨⬜  Downloading web components') +
        chalk.white.dim('  |  Almost there'),
      successText: chalk.white.bold('🟩🟩🟩⬜  Downloaded web components'),
      failText: chalk.white.bold(
        '🟩🟩🟥⬜  Failed to download web components  |  Development environment will not function'
      ),
    })
  } catch (err) {
    /* no feedback here */
  }

  // Initialize git repository
  try {
    await oraPromise(initGitRepo(config, choices), {
      text:
        chalk.white.bold('🟩🟩🟩⬜  Initializing git repository') +
        chalk.white.dim('  |  You have git, right?'),
      successText: chalk.white.bold('🟩🟩🟩🟩  Initialized git repository'),
      failText:
        chalk.white.bold('🟩🟩🟩🟥  Failed to initialize git repository') +
        chalk.white.dim('  |  This does not stop you from developing your design'),
    })
  } catch (err) {
    /* no git no worries */
  }

  // All done. Show tips
  showTips(config, choices)
}