const fs = require('fs')
const espree = require('espree')
const format = require('string-format')
const core = require('@actions/core')

// Parse the AST
const espreeOptions = {
  ecmaVersion: 6,
  sourceType: 'module',
  range: true
}

class ConfigParser {
  constructor(staticSiteConfig) {
    this.pathPropertyNuxt = `router: {\n        base: '{0}'\n    }`
    this.pathPropertyNext = `basePath: '{0}'`
    this.pathPropertyGatsby = `pathPrefix: '{0}'`
    this.configskeleton = `export default {\n    {0}\n}`
    this.staticSiteConfig = staticSiteConfig
    this.config = fs.existsSync(this.staticSiteConfig.filePath)
      ? fs.readFileSync(this.staticSiteConfig.filePath, 'utf8')
      : null
    this.validate()
  }

  validate() {
    if (!this.config) {
      core.info(`original raw configuration was empty:\n${this.config}`)
      core.info('Generating a default configuration to start from...')

      // Update the `config` property with a default configuration file
      this.config = this.generateConfigFile()
    }
  }

  generateConfigFile() {
    switch (this.staticSiteConfig.type) {
      case 'nuxt':
        return format(
          this.configskeleton,
          format(this.pathPropertyNuxt, this.staticSiteConfig.newPath)
        )
        break
      case 'next':
        return format(
          this.configskeleton,
          format(this.pathPropertyNext, this.staticSiteConfig.newPath)
        )
        break
      case 'gatsby':
        return format(
          this.configskeleton,
          format(this.pathPropertyGatsby, this.staticSiteConfig.newPath)
        )
        break
      default:
        throw 'Unknown config type'
    }
  }

  generateConfigProperty() {
    switch (this.staticSiteConfig.type) {
      case 'nuxt':
        return format(this.pathPropertyNuxt, this.staticSiteConfig.newPath)
        break
      case 'next':
        return format(this.pathPropertyNext, this.staticSiteConfig.newPath)
        break
      case 'gatsby':
        return format(this.pathPropertyGatsby, this.staticSiteConfig.newPath)
        break
      default:
        throw 'Unknown config type'
    }
  }

  parse() {
    core.info(`original configuration:\n${this.config}`)
    const ast = espree.parse(this.config, espreeOptions)

    // Find the default export declaration node
    var exportNode = ast.body.find(node => node.type === 'ExpressionStatement')
    if (exportNode) {
      var property = this.getPropertyModuleExport(exportNode)
    } else {
      exportNode = ast.body.find(
        node => node.type === 'ExportDefaultDeclaration'
      )
      if (!exportNode) throw 'Unable to find default export'
      var property = this.getPropertyExportDefault(exportNode)
    }

    if (property) {
      switch (this.staticSiteConfig.type) {
        case 'nuxt':
          this.parseNuxt(property)
          break
        case 'next':
        case 'gatsby':
          this.parseNextGatsby(property)
          break
        default:
          throw 'Unknown config type'
      }
    }
    core.info(`parsed configuration:\n${this.config}`)
    fs.writeFileSync(this.staticSiteConfig.filePath, this.config)
    return this.config
  }

  getPropertyModuleExport(exportNode) {
    var propertyNode = exportNode.expression.right.properties.find(
      node =>
        node.key.type === 'Identifier' &&
        node.key.name === this.staticSiteConfig.pathName
    )

    if (!propertyNode) {
      core.info(
        'Unable to find property, insert it :  ' +
          this.staticSiteConfig.pathName
      )
      if (exportNode.expression.right.properties.length > 0) {
        this.config =
          this.config.slice(
            0,
            exportNode.expression.right.properties[0].range[0]
          ) +
          this.generateConfigProperty() +
          ',\n' +
          this.config.slice(exportNode.expression.right.properties[0].range[0])
        core.info('new config = \n' + this.config)
      } else {
        this.config =
          this.config.slice(0, exportNode.expression.right.range[0] + 1) +
          '\n    ' +
          this.generateConfigProperty() +
          '\n' +
          this.config.slice(exportNode.expression.right.range[1] - 1)
        core.info('new config = \n' + this.config)
      }
    }
    return propertyNode
  }

  getPropertyExportDefault(exportNode) {
    var propertyNode = exportNode.declaration.properties.find(
      node =>
        node.key.type === 'Identifier' &&
        node.key.name === this.staticSiteConfig.pathName
    )

    if (!propertyNode) {
      core.info(
        'Unable to find property, insert it ' + this.staticSiteConfig.pathName
      )
      if (exportNode.declaration.properties.length > 0) {
        this.config =
          this.config.slice(0, exportNode.declaration.properties[0].range[0]) +
          this.generateConfigProperty() +
          ',\n' +
          this.config.slice(exportNode.declaration.properties[0].range[0])
        core.info('new config = \n' + this.config)
      } else {
        this.config =
          this.config.slice(0, exportNode.declaration.range[0] + 1) +
          '\n    ' +
          this.generateConfigProperty() +
          '\n' +
          this.config.slice(exportNode.declaration.range[1] - 1)
        core.info('new config = \n' + this.config)
      }
    }

    return propertyNode
  }

  parseNuxt(propertyNode) {
    // Find the base node
    if (propertyNode && propertyNode.value.type === 'ObjectExpression') {
      var baseNode = propertyNode.value.properties.find(
        node =>
          node.key.type === 'Identifier' &&
          node.key.name === this.staticSiteConfig.subPathName
      ) //'base')
      if (baseNode) {
        // Swap the base value by a hardcoded string and print it
        this.config =
          this.config.slice(0, baseNode.value.range[0]) +
          `'${this.staticSiteConfig.newPath}'` +
          this.config.slice(baseNode.value.range[1])
      }
    }
  }

  parseNextGatsby(pathNode) {
    if (pathNode) {
      this.config =
        this.config.slice(0, pathNode.value.range[0]) +
        `'${this.staticSiteConfig.newPath}'` +
        this.config.slice(pathNode.value.range[1])
    }
  }
}

module.exports = {ConfigParser}