#!/usr/bin/env node
import fs from 'fs'
import path from 'path'
import program from 'commander'
import walk from 'walk-sync'
import { escapeRegExp, last } from 'lodash-es'
import yaml from 'js-yaml'
import patterns from '../../lib/patterns.js'

// [start-readme]
//
// This script is run on a writer's machine while developing Early Access content locally. It
// updates the data and image paths to either include `early-access` or remove it.
//
// [end-readme]

const earlyAccessContent = path.posix.join(process.cwd(), 'content/early-access')
const earlyAccessData = path.posix.join(process.cwd(), 'data/early-access')
const earlyAccessImages = path.posix.join(process.cwd(), 'assets/images/early-access')

program
  .description('Update data and image paths.')
  .option(
    '-p, --path-to-early-access-content-file <PATH>',
    'Path to a specific content file. Defaults to all Early Access content files if not provided.'
  )
  .option('-a, --add', 'Add "early-access" to data and image paths.')
  .option('-r, --remove', 'Remove "early-access" from data and image paths.')
  .parse(process.argv)

const { add, remove, pathToEarlyAccessContentFile } = program.opts()

if (!(add || remove)) {
  console.error('Error! Must specify either `--add` or `--remove`.')
  process.exit(1)
}

let earlyAccessContentAndDataFiles
if (pathToEarlyAccessContentFile) {
  earlyAccessContentAndDataFiles = path.posix.join(process.cwd(), pathToEarlyAccessContentFile)

  if (!fs.existsSync(earlyAccessContentAndDataFiles)) {
    console.error(
      `Error! ${pathToEarlyAccessContentFile} can't be found. Make sure the path starts with 'content/early-access'.`
    )
    process.exit(1)
  }
  earlyAccessContentAndDataFiles = [earlyAccessContentAndDataFiles]
} else {
  // Gather the EA content and data files
  earlyAccessContentAndDataFiles = walk(earlyAccessContent, {
    includeBasePath: true,
    directories: false,
  }).concat(walk(earlyAccessData, { includeBasePath: true, directories: false }))
}

// Update the EA content and data files
earlyAccessContentAndDataFiles.forEach((file) => {
  const oldContents = fs.readFileSync(file, 'utf8')

  // Get all the data references in each file that exist in data/early-access
  const dataRefs = (oldContents.match(patterns.dataReference) || []).filter((dataRef) =>
    dataRef.includes('variables') ? checkVariable(dataRef) : checkReusable(dataRef)
  )

  // Get all the image references in each file that exist in assets/images/early-access
  const imageRefs = (oldContents.match(patterns.imagePath) || []).filter((imageRef) =>
    checkImage(imageRef)
  )

  const replacements = {}

  if (add) {
    dataRefs
      // Since we're adding early-access to the path, filter for those that do not already include it
      .filter((dataRef) => !dataRef.includes('data early-access.'))
      // Add to the { oldRef: newRef } replacements object
      .forEach((dataRef) => {
        replacements[dataRef] = dataRef.replace(/({% data )(.*)/, '$1early-access.$2')
      })

    imageRefs
      // Since we're adding early-access to the path, filter for those that do not already include it
      .filter((imageRef) => !imageRef.split('/').includes('early-access'))
      // Add to the { oldRef: newRef } replacements object
      .forEach((imageRef) => {
        replacements[imageRef] = imageRef.replace('/assets/images/', '/assets/images/early-access/')
      })
  }

  if (remove) {
    dataRefs
      // Since we're removing early-access from the path, filter for those that include it
      .filter((dataRef) => dataRef.includes('{% data early-access.'))
      // Add to the { oldRef: newRef } replacements object
      .forEach((dataRef) => {
        replacements[dataRef] = dataRef.replace('early-access.', '')
      })

    imageRefs
      // Since we're removing early-access from the path, filter for those that include it
      .filter((imageRef) => imageRef.split('/').includes('early-access'))
      // Add to the { oldRef: newRef } replacements object
      .forEach((imageRef) => {
        replacements[imageRef] = imageRef.replace('/assets/images/early-access/', '/assets/images/')
      })
  }

  // Return early if nothing to replace
  if (!Object.keys(replacements).length) {
    return
  }

  // Make the replacement in the content
  let newContents = oldContents
  Object.entries(replacements).forEach(([oldRef, newRef]) => {
    newContents = newContents.replace(new RegExp(escapeRegExp(oldRef), 'g'), newRef)
  })

  // Write the updated content
  fs.writeFileSync(file, newContents)
})

console.log('Done! Run "git status" in your docs-early-access checkout to see the changes.\n')

function checkVariable(dataRef) {
  // Get the data filepath from the data reference,
  // where the data reference looks like: {% data variables.foo.bar %}
  // and the data filepath looks like: data/variables/foo.yml with key of 'bar'.
  const variablePathArray = dataRef
    .match(/{% data (.*?) %}/)[1]
    .split('.')
    // If early access is part of the path, remove it (since the path below already includes it)
    .filter((n) => n !== 'early-access')

  // Given a string `variables.foo.bar` split into an array, we want the last segment 'bar', which is the variable key.
  // Then pop 'bar' off the array because it's not really part of the filepath.
  // The filepath we want is `variables/foo.yml`.
  const variableKey = last(variablePathArray)
  variablePathArray.pop()
  const variablePath = path.posix.join(earlyAccessData, `${variablePathArray.join('/')}.yml`)

  // If the variable file doesn't exist in data/early-access, exclude it
  if (!fs.existsSync(variablePath)) return false

  // If the variable file exists but doesn't have the referenced key, exclude it
  const variableFileContent = yaml.load(fs.readFileSync(variablePath, 'utf8'))
  return variableFileContent[variableKey]
}

function checkReusable(dataRef) {
  // Get the data filepath from the data reference,
  // where the data reference looks like: {% data reusables.foo.bar %}
  // and the data filepath looks like: data/reusables/foo/bar.md.
  const reusablePath = dataRef
    .match(/{% data (.*?) %}/)[1]
    .split('.')
    // If early access is part of the path, remove it (since the path below already includes it)
    .filter((n) => n !== 'early-access')
    .join('/')

  // If the reusable file doesn't exist in data/early-access, exclude it
  return fs.existsSync(`${path.posix.join(earlyAccessData, reusablePath)}.md`)
}

function checkImage(imageRef) {
  const imagePath = imageRef
    .replace('/assets/images/', '')
    // If early access is part of the path, remove it (since the path below already includes it)
    .replace('early-access', '')

  // If the image file doesn't exist in assets/images/early-access, exclude it
  return fs.existsSync(path.posix.join(earlyAccessImages, imagePath))
}