import { HttpContext } from '@adonisjs/core/http'
import { join, dirname } from 'node:path'
import { mkdirSync, writeFileSync, readFileSync, existsSync, cpSync } from 'node:fs'
import { modelToSchema } from '#services/swagger_model'
import handlebars from 'handlebars'
import {
  getDatabaseTables,
  getColumnsForTable,
  getForeignKeysReferencing,
} from '#services/database_inspector'

handlebars.registerHelper('eq', (a, b) => a === b)
handlebars.registerHelper('not', (v) => !v)
handlebars.registerHelper('or', (a, b) => a || b)
handlebars.registerHelper('and', (a, b) => a && b)

function renderTemplate(templatePath: string, context: any): string {
  const raw = readFileSync(templatePath, 'utf8')
  const template = handlebars.compile(raw)
  return template(context)
}

export default class MakeModuleController {
  capitalize(str: string) {
    return str.charAt(0).toUpperCase() + str.slice(1)
  }

  camelCase(str: string) {
    return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase())
  }

  pascalCase(str: string) {
    return this.capitalize(this.camelCase(str))
  }

  snakeCase(str: string) {
    return str.slice(0, str.length - 1)
  }

  mapDBTypeToTs(type: string): string {
    if (type.includes('int')) return 'number'
    if (type === 'boolean') return 'boolean'
    if (type.includes('timestamp') || type === 'date') return 'DateTime'
    return 'string'
  }

  mapDBTypeToValidator(type: string): string {
    if (
      type.includes('int') ||
      type === 'numeric' ||
      type === 'decimal' ||
      type === 'real' ||
      type === 'double precision'
    ) {
      return 'number'
    }

    if (type === 'boolean') return 'boolean'
    if (type.includes('timestamp') || type === 'date') return 'date'
    return 'string'
  }

  mapDBTypeToFrontend(type: string): string {
    if (type.includes('int') || type === 'numeric' || type === 'bigint') return 'number'
    if (type === 'boolean') return 'boolean'
    if (type.includes('timestamp') || type === 'date') return 'IsoDateString'
    return 'string'
  }

  async generateRelationships(table: string) {
    const lines: string[] = []
    const imports: Set<string> = new Set()

    const columns = await getColumnsForTable(table)
    const references = await getForeignKeysReferencing(table)

    for (const col of columns) {
      if (col.column_name.endsWith('_id')) {
        const refTable = col.column_name.replace('_id', '')
        const refModel = this.capitalize(refTable)
        imports.add('belongsTo')
        lines.push(
          `  @belongsTo(() => ${refModel})\n  declare ${refTable}: BelongsTo<typeof ${refModel}>`
        )
      }
    }

    for (const ref of references) {
      const relModel = this.capitalize(ref.table_name)
      imports.add('hasMany')
      lines.push(
        `  @hasMany(() => ${relModel})\n  declare ${ref.table_name}: HasMany<typeof ${relModel}>`
      )
    }

    return {
      imports: Array.from(imports),
      code: lines,
    }
  }

  async tables({ response }: HttpContext) {
    const tables = await getDatabaseTables()
    return response.ok(tables)
  }

  async generate({ request, response }: HttpContext) {
    const {
      name,
      table,
      generate,
      form,
      formDefinition,
      dataTable,
      list,
      formDialog,
      menu,
      module,
    } = request.only([
      'name',
      'table',
      'generate',
      'form',
      'formDefinition',
      'dataTable',
      'list',
      'formDialog',
      'menu',
      'module',
    ])

    const appBase = process.cwd()
    const backendTplDir = join(appBase, 'app/templates/backend')
    const apiTplDir = join(appBase, 'app/templates/backend/api')
    const moduleName = this.capitalize(name)
    const modulePath = join(appBase, 'modules', moduleName)

    const snake = this.snakeCase(table)
    // Backend and admin are sibling workspaces under apps/.
    const clientBase = join(appBase, '..', 'admin', 'src', 'modules', moduleName)
    const templateModuleDir = join(appBase, '..', 'admin', 'src', 'modules', '_template')

    const paths = {
      // backend
      controller: join(modulePath, 'controller', `${snake}_controller.ts`),
      model: join(modulePath, 'model', `${snake}.ts`),
      // validatorCreate: join('app', 'validators', `${snake}_create_validator.ts`),
      // validatorUpdate: join('app', 'validators', `${snake}_update_validator.ts`),
      validatorCreate: join(modulePath, 'validators', `${snake}_create_validator.ts`),
      validatorUpdate: join(modulePath, 'validators', `${snake}_update_validator.ts`),
      routes: join(modulePath, 'routes.ts'),
      policy: join(modulePath, 'policy', `${snake}_policy.ts`),
      policiesMain: join(appBase, 'app', 'policies', 'main.ts'),
      permissionsConfig: join(modulePath, 'config', 'permissions.ts'),

      // API subtree
      apiController: join(modulePath, 'api', 'controllers', `${snake}_api_controller.ts`),
      // apiValidatorCreate: join('app', 'validators', `${snake}_create_api_validator.ts`),
      // apiValidatorUpdate: join('app', 'validators', `${snake}_update_api_validator.ts`),
      apiValidatorCreate: join(modulePath, 'api', 'validators', `${snake}_create_api_validator.ts`),
      apiValidatorUpdate: join(modulePath, 'api', 'validators', `${snake}_update_api_validator.ts`),
      apiRoutes: join(modulePath, 'api', 'routes.ts'),

      // tests
      testController: join(
        appBase,
        'tests',
        'modules',
        moduleName,
        `${this.snakeCase(table)}.spec.ts`
      ),
      testApi: join(
        appBase,
        'tests',
        'modules',
        moduleName,
        `${this.snakeCase(table)}.api.spec.ts`
      ),

      // frontend
      clientModule: clientBase,
      clientForm: join(clientBase, 'view', 'forms', 'MainForm', 'Component.tsx'),
      clientFormDefinition: join(clientBase, 'view', 'forms', 'MainForm', 'form.ts'),
      clientDatatable: join(clientBase, 'view', 'widgets', 'DataTable.tsx'),
      clientList: join(clientBase, 'pages', 'ListPage', 'index.tsx'),
      clientDialog: join(clientBase, 'view', 'widgets', 'ManageTrigger.tsx'),
      clientConfig: join(clientBase, 'config', 'meta.ts'),
      clientMenu: join(clientBase, 'config', 'menu.ts'),
      clientModuleConfig: join(clientBase, 'config', 'module.ts'),
      clientEntity: join(clientBase, 'entities', 'Entity.ts'),
    }

    if (existsSync(templateModuleDir)) {
      cpSync(templateModuleDir, paths.clientModule, { recursive: true })
    }

    Object.values(paths).forEach((filePath) => {
      mkdirSync(dirname(filePath), { recursive: true })
    })

    const columns = await getColumnsForTable(table)
    const modelClass = this.capitalize(table)
    const relationship = await this.generateRelationships(table)

    const enhancedColumns = columns.map((col) => {
      const colName = col.column_name
      const camelName = this.camelCase(colName)
      const type = this.mapDBTypeToTs(col.data_type) + (col.is_nullable === 'YES' ? ' | null' : '')
      return {
        name: colName,
        camelCase: camelName,
        type,
        isPrimary: colName === 'id',
        isPassword: colName === 'password',
        isEmail: colName === 'email',
        isDateTime: ['created_at', 'updated_at'].includes(colName),
        isSpecial: ['created_at', 'updated_at', 'deleted_at'].includes(colName),
        isRequired: col.is_nullable === 'NO',
        isNullable: col.is_nullable === 'YES',
        validatorType: this.mapDBTypeToValidator(col.data_type),
        needsTrim:
          this.mapDBTypeToValidator(col.data_type) === 'string' &&
          colName !== 'email' &&
          colName !== 'password',
      }
    })

    const sampleFor = (col: any) => {
      const t = col.validatorType
      if (t === 'number') return 1
      if (t === 'boolean') return false
      if (t === 'date') return `'${new Date().toISOString()}'`
      return `'sample_${col.camelCase}'`
    }

    const createFields = enhancedColumns
      .filter((c) => !c.isPrimary && !c.isSpecial)
      .map((c) => ({
        camelCase: c.camelCase,
        sampleValue: sampleFor(c),
        column_name: c.name,
      }))

    const updateFields = enhancedColumns
      .filter((c) => !c.isPrimary && !c.isDateTime)
      .map((c) => ({
        camelCase: c.camelCase,
        sampleValue: sampleFor(c),
        column_name: c.name,
      }))

    // minimal insert json for show/update/destroy fixtures
    const insertJson = `{
      ${createFields.map((f) => `  ${f.column_name}: ${f.sampleValue}`).join(',\n')}
      }`

    const frontendFields = columns.map((col) => {
      return {
        name: col.column_name,
        type:
          this.mapDBTypeToFrontend(col.data_type) + (col.is_nullable === 'YES' ? ' | null' : ''),
      }
    })

    // FRONTEND writer
    writeFileSync(paths.clientForm, form ?? '', 'utf8')
    writeFileSync(paths.clientFormDefinition, formDefinition ?? '', 'utf8')
    writeFileSync(paths.clientDatatable, dataTable ?? '', 'utf8')
    writeFileSync(paths.clientList, list ?? '', 'utf8')
    writeFileSync(paths.clientDialog, formDialog ?? '', 'utf8')
    writeFileSync(paths.clientMenu, menu ?? '', 'utf8')
    writeFileSync(paths.clientModuleConfig, module ?? '', 'utf8')

    const configContent = renderTemplate(join(backendTplDir, '..', 'frontend', 'config.hbs'), {
      name,
    })
    writeFileSync(paths.clientConfig, configContent)

    const entityContent = renderTemplate(join(backendTplDir, '..', 'frontend', 'entity.hbs'), {
      fields: frontendFields,
    })

    writeFileSync(paths.clientEntity, entityContent)

    // BACKEND: model
    if (generate.includes('model')) {
      const content = renderTemplate(join(backendTplDir, 'model.hbs'), {
        name,
        pascalCaseName: this.pascalCase(name),
        capName: this.capitalize(name),
        className: modelClass,
        imports: relationship.imports.join(', '),
        columns: enhancedColumns,
        relationships: relationship.code,
        hasPassword: columns.some((col) => col.column_name === 'password'),
      })
      await writeFileSync(paths.model, content)
    }

    // BACKEND: controller
    if (generate.includes('controller')) {
      const content = renderTemplate(join(backendTplDir, 'controller.hbs'), {
        pascalCaseName: this.pascalCase(name),
        modelName: modelClass,
        capName: this.capitalize(name),
        moduleName,
        tableName: table,
        snakeName: snake,
        name,
      })
      writeFileSync(paths.controller, content)

      const testsTplDir = join(backendTplDir, 'tests')

      // controller tests
      const ctrlSpec = renderTemplate(join(testsTplDir, 'controller.spec.hbs'), {
        pascalCaseName: this.pascalCase(name),
        snakeCaseName: this.snakeCase(table),
        tableName: table,
        createFields,
        updateFields,
        insertJson,
      })
      mkdirSync(dirname(paths.testController), { recursive: true })
      writeFileSync(paths.testController, ctrlSpec, 'utf8')
    }

    // BACKEND: routes
    if (generate.includes('routes')) {
      const content = renderTemplate(join(backendTplDir, 'routes.hbs'), {
        name,
        capName: this.capitalize(name),
        className: moduleName,
        routeName: name,
        snakeCaseName: snake,
      })
      writeFileSync(paths.routes, content)
    }

    // BACKEND: validators
    if (generate.includes('validator')) {
      const createContent = renderTemplate(join(backendTplDir, 'validator.hbs'), {
        className: moduleName,
        functionName: `create${moduleName}Validator`,
        fields: enhancedColumns.filter((col) => !col.isPrimary && !col.isSpecial),
      })
      writeFileSync(paths.validatorCreate, createContent)

      const updateContent = renderTemplate(join(backendTplDir, 'validator.hbs'), {
        className: moduleName,
        functionName: `update${moduleName}Validator`,
        fields: enhancedColumns.filter((col) => !col.isPrimary && !col.isDateTime),
      })
      writeFileSync(paths.validatorUpdate, updateContent)
    }

    // BACKEND: policy + permissions
    if (generate.includes('policy')) {
      const policyTpl = join(backendTplDir, 'policy.hbs')
      const base = name.toLowerCase()
      const slugBase = base.endsWith('s') ? base : `${base}s`
      const policyContent = renderTemplate(policyTpl, {
        name,
        slugBase,
        moduleName,
        modelName: modelClass,
        pascalCaseName: this.pascalCase(name),
      })
      writeFileSync(paths.policy, policyContent)

      if (!existsSync(paths.policiesMain)) {
        mkdirSync(dirname(paths.policiesMain), { recursive: true })
        writeFileSync(paths.policiesMain, `export const policies = {}\n`)
      }
      const capName = this.capitalize(name)
      const key = `${modelClass}Policy`
      const importLine = `  ${key}: () => import('#modules/${capName}/policy/${name}_policy'),`
      const current = readFileSync(paths.policiesMain, 'utf8')

      if (current.includes('export const policies =')) {
        if (!current.includes(importLine)) {
          const updated = current.replace(
            /export const policies\s*=\s*\{\s*/m,
            (m) => m + '\n' + importLine + '\n'
          )
          writeFileSync(paths.policiesMain, updated)
        }
      } else {
        writeFileSync(paths.policiesMain, `export const policies = {\n${importLine}\n}\n`)
      }

      const labelBase = this.capitalize(name.endsWith('s') ? name.slice(0, -1) : name)
      const perms = [
        { action: 'view', slug: `${name}s.view`, name: `${labelBase} view` },
        { action: 'create', slug: `${name}s.create`, name: `${labelBase} create` },
        { action: 'update', slug: `${name}s.update`, name: `${labelBase} update` },
        { action: 'delete', slug: `${name}s.delete`, name: `${labelBase} delete` },
      ]

      const fileContents =
        'export default [\n' +
        perms.map((p) => `  {\n    slug: '${p.slug}',\n    name: '${p.name}',\n  },`).join('\n') +
        '\n]\n'

      if (!existsSync(paths.permissionsConfig)) {
        mkdirSync(dirname(paths.permissionsConfig), { recursive: true })
        writeFileSync(paths.permissionsConfig, fileContents, 'utf8')
      }
    }

    // API subtree
    if (generate.includes('api')) {
      const { default: genModel } = await import(paths.model)
      const test = await modelToSchema(genModel)
      console.warn(test)
      const apiCtx = {
        pascalCaseName: this.pascalCase(name),
        modelName: modelClass,
        capName: this.capitalize(name),
        moduleName,
        tableName: table,
        snakeCaseName: snake,
        name,
        snake,
        swaggerModel: await modelToSchema(genModel),
      }

      // Controller
      const apiControllerTpl = join(apiTplDir, 'controller.hbs')
      const apiControllerContent = renderTemplate(apiControllerTpl, apiCtx)
      writeFileSync(paths.apiController, apiControllerContent, 'utf8')

      // test
      const testsTplDir = join(backendTplDir, 'tests')
      const apiSpec = renderTemplate(join(testsTplDir, 'api.spec.hbs'), {
        snakeCaseName: this.snakeCase(table),
        createFields,
      })
      writeFileSync(paths.testApi, apiSpec, 'utf8')

      // Validators
      const apiValidatorTpl = join(apiTplDir, 'validator.hbs')
      const apiCreateValidatorContent = renderTemplate(apiValidatorTpl, {
        ...apiCtx,
        className: moduleName,
        functionName: `create${moduleName}ApiValidator`,
        fields: enhancedColumns.filter((c) => !c.isPrimary && !c.isSpecial),
      })
      writeFileSync(paths.apiValidatorCreate, apiCreateValidatorContent, 'utf8')

      const apiUpdateValidatorContent = renderTemplate(apiValidatorTpl, {
        ...apiCtx,
        className: moduleName,
        functionName: `update${moduleName}ApiValidator`,
        fields: enhancedColumns.filter((c) => !c.isPrimary && !c.isDateTime),
      })
      writeFileSync(paths.apiValidatorUpdate, apiUpdateValidatorContent, 'utf8')

      // Routes
      const apiRoutesTpl = join(apiTplDir, 'routes.hbs')
      const apiRoutesContent = renderTemplate(apiRoutesTpl, apiCtx)
      writeFileSync(paths.apiRoutes, apiRoutesContent, 'utf8')
    }

    return response.ok({ message: `Module "${moduleName}" created based on table "${table}"` })
  }

  public async columns({ request, response }: HttpContext) {
    const { table } = request.params()
    const columns = await getColumnsForTable(table)
    const enhancedColumns = columns.map((col) => {
      const colName = col.column_name
      const type = this.mapDBTypeToTs(col.data_type) + (col.is_nullable === 'YES' ? ' | null' : '')
      return {
        name: colName,
        type,
        isDateTime: ['created_at', 'updated_at'].includes(colName),
      }
    })

    return response.ok({ columns: enhancedColumns })
  }
}