import * as pug from 'pug'
import * as path from 'path'
import * as fs from 'fs'
import * as postcss from 'postcss'
import * as delta from '@kolcelabs/delta'
import { set } from '../server/utils'
import * as copy from 'copy'
import chalk from 'chalk'

export function findFiles(data) {
  const found = (dir, matchPattern, filelist: Array<string> = []): Array<string> => {

    fs.readdirSync(dir).forEach(file => {
      const filePath = path.join(dir, file) // Get the full path

      filelist = fs.statSync(filePath).isDirectory() // Check if we are in a directory then
        ? found(filePath, matchPattern, filelist) // Continue the recursion
        : filelist.concat(matchPattern.test(filePath) ? filePath : '') // Otherwise check if matches the pattern
    })

    return filelist.filter(x => x) // Return the list of found files
  }

  return set(data, 'sourceFiles', found(data.inputDir, data.filePattern))
}

export function findPugData(data) {
  const pugDataPath = path.normalize(`${data.inputDir}/data.js`)
  const pugData = fs.statSync(pugDataPath).isFile()
    ? require(pugDataPath)
    : {}

  return set(data, 'pugData', pugData)
}

export function compilePug(data) {
  const pugFiles = data.sourceFiles.filter(x => /\.pug$/.test(x)).map(inputFile => ({
    input: inputFile,
    output: inputFile.replace(data.inputDir, data.outputDir || '').replace('.pug', '.html'),
    content: pug.renderFile(inputFile, data.pugData)
  })).concat(data.compiledFiles || [])

  return set(data, 'compiledFiles', pugFiles)
}

export function compileDelta(data) {
  const deltaFiles = data.sourceFiles.filter(x => /\.pcss$/.test(x)).map(inputFile => {
    const output = inputFile.replace(data.inputDir, data.outputDir || '').replace('.pcss', '.css')
    const pcss = fs.readFileSync(inputFile, { encoding: 'utf-8' })
    const content = postcss([delta]).process(pcss, { from: inputFile, to: output }).css

    return { input: inputFile, output: output, content: content }
  }).concat(data.compiledFiles || [])

  return set(data, 'compiledFiles', deltaFiles)
}

export function writeFiles(data) {
  data.compiledFiles.forEach(file => {
    try {
      fs.mkdirSync(path.dirname(file.output), { recursive: true })
      fs.writeFileSync(file.output, file.content)
      console.log(chalk.green('✔  Written: ') + chalk.gray(file.output))
    } catch (e) {
      throw e
    }
  })

  return data
}

export function copyFiles(input, output, pattern) {
  copy(`${input}/**/${pattern}`, output, (err, file) => {
    if (err) throw err
    file.forEach(element => console.log(chalk.green('✔  Written: ') + chalk.gray(element.dest)))
  })
}