import { createCommand } from '@trailhead/cli/command'
import { ok, err, createCoreError } from '@trailhead/core'
import { consola } from 'consola'
import { validateJsonFile, validateFileExists } from '../lib/validators.ts'
import { resolve } from 'path'

export const validateCommand = createCommand({
  name: 'validate',
  description: 'Validate files and data',
  flags: {
    file: {
      type: 'string',
      description: 'File to validate'
    },
    type: {
      type: 'string',
      description: 'Validation type (json, config, package)'
    }
  },
  async handler(args) {
    const { file, type } = args.flags

    if (!file) {
      consola.info('Usage: {{packageName}} validate --file <path> [--type <type>]')
      consola.info('')
      consola.info('Supported types:')
      consola.info('  json     - Validate JSON syntax')
      consola.info('  config   - Validate configuration file')
      consola.info('  package  - Validate package.json')
      return ok(undefined)
    }

    const filepath = resolve(file)
    
    // Check if file exists
    const fileExistsResult = validateFileExists(filepath)
    if (fileExistsResult.isErr()) {
      return fileExistsResult
    }

    consola.start(`Validating: ${filepath}`)

    switch (type) {
      case 'json':
        return validateJson(filepath)
      case 'config':
        return validateConfig(filepath)
      case 'package':
        return validatePackageJson(filepath)
      default:
        // Auto-detect based on filename
        if (filepath.endsWith('package.json')) {
          return validatePackageJson(filepath)
        } else if (filepath.endsWith('config.json')) {
          return validateConfig(filepath)
        } else if (filepath.endsWith('.json')) {
          return validateJson(filepath)
        } else {
          return err(createCoreError('UNKNOWN_VALIDATION_TYPE', 'Unknown validation type', {
            component: '{{packageName}}',
            operation: 'validate',
            details: 'Specify --type or use a recognized file extension'
          }))
        }
    }
  }
})

function validateJson(filepath: string) {
  const result = validateJsonFile(filepath)
  
  if (result.isErr()) {
    consola.error('❌ JSON validation failed')
    return result
  }

  consola.success('✅ Valid JSON file')
  return ok(undefined)
}

function validateConfig(filepath: string) {
  // Import config schema if available
  try {
    const { configSchema } = require('../lib/config-schema.ts')
    const result = validateJsonFile(filepath, configSchema)
    
    if (result.isErr()) {
      consola.error('❌ Configuration validation failed')
      return result
    }

    consola.success('✅ Valid configuration file')
    return ok(undefined)
  } catch {
    // Fallback to basic JSON validation
    return validateJson(filepath)
  }
}

function validatePackageJson(filepath: string) {
  const result = validateJsonFile(filepath)
  
  if (result.isErr()) {
    consola.error('❌ package.json validation failed')
    return result
  }

  const data = result.value

  // Basic package.json structure validation
  if (!data.name) {
    return err(createCoreError('INVALID_PACKAGE_JSON', 'package.json missing required "name" field', {
      component: '{{packageName}}',
      operation: 'validatePackageJson'
    }))
  }

  if (!data.version) {
    return err(createCoreError('INVALID_PACKAGE_JSON', 'package.json missing required "version" field', {
      component: '{{packageName}}',
      operation: 'validatePackageJson'
    }))
  }

  consola.success('✅ Valid package.json file')
  consola.info(`   Name: ${data.name}`)
  consola.info(`   Version: ${data.version}`)
  
  return ok(undefined)
}