#!/usr/bin/env node
// SPDX-FileCopyrightText: 2025-2026 Vasyl Zakharchenko
// SPDX-License-Identifier: MIT

import { Command } from "commander";
import dotenv from "dotenv";
import inquirer from "inquirer";
import fs from "node:fs";
import path from "node:path";
import { generateModels, type GenerateModelsOptions } from "./actions/generate-models";
import { createMigration, type CreateMigrationOptions } from "./actions/migrations-create";
import { updateMigration, type UpdateMigrationOptions } from "./actions/migrations-update";
import { dropMigration, type DropMigrationOptions } from "./actions/migrations-drops";
import { createSchema, type CreateSchemaOptions } from "./actions/schema-create";

const ENV_PATH = path.resolve(process.cwd(), ".env");
// 🔄 Load environment variables from `.env` file
dotenv.config({ path: ENV_PATH });

/**
 * Resolved configuration shared across all CLI commands.
 */
interface CliConfig {
  host?: string;
  port?: number;
  user?: string;
  password?: string;
  dbName?: string;
  output?: string;
  versionField?: string;
  entitiesPath?: string;
  force?: boolean;
}

/**
 * Raw options object provided by Commander to each command action.
 * All values arrive as strings (or booleans for flags) from the CLI.
 */
interface CommandOptions {
  host?: string;
  port?: string;
  user?: string;
  password?: string;
  dbName?: string;
  output?: string;
  versionField?: string;
  entitiesPath?: string;
  force?: boolean;
  saveEnv?: boolean;
}

/**
 * Raw answers returned by Inquirer. Every prompted value is a string,
 * including `port`, which is converted to a number before it reaches `CliConfig`.
 */
interface PromptAnswers {
  host?: string;
  port?: string;
  user?: string;
  password?: string;
  dbName?: string;
  output?: string;
  versionField?: string;
  entitiesPath?: string;
}

const saveEnvFile = (config: CliConfig) => {
  let envContent = "";
  const envFilePath = ENV_PATH;

  if (fs.existsSync(envFilePath)) {
    envContent = fs.readFileSync(envFilePath, "utf8");
  }

  const envVars = envContent
    .split("\n")
    .filter((line) => line.trim() !== "" && !line.startsWith("#"))
    .reduce<Record<string, string>>((acc, line) => {
      const [key, ...value] = line.split("=");
      acc[key] = value.join("=");
      return acc;
    }, {});

  Object.entries(config).forEach(([key, value]) => {
    envVars[`FORGE_SQL_ORM_${key.toUpperCase()}`] = String(value);
  });

  const updatedEnvContent = Object.entries(envVars)
    .map(([key, value]) => `${key}=${value}`)
    .join("\n");

  fs.writeFileSync(envFilePath, updatedEnvContent, { encoding: "utf8" });

  console.log("✅ Configuration saved to .env without overwriting other variables.");
};

/**
 * Prompts the user for missing parameters using Inquirer.js.
 * @param config - The current configuration object.
 * @param defaultOutput - Default output path.
 * @param customAskMissingParams - Optional function for additional prompts.
 * @returns Updated configuration with user input.
 */
const askMissingParams = async (
  config: CliConfig,
  defaultOutput: string,
  customAskMissingParams?: (cfg: CliConfig, questions: unknown[]) => void,
): Promise<CliConfig> => {
  const questions: unknown[] = [];

  if (!config.host)
    questions.push({
      type: "input",
      name: "host",
      message: "Enter database host:",
      default: "localhost",
    });

  if (!config.port)
    questions.push({
      type: "input",
      name: "port",
      message: "Enter database port:",
      default: "3306",
      validate: (input: string) => !Number.isNaN(Number.parseInt(input, 10)),
    });

  if (!config.user)
    questions.push({
      type: "input",
      name: "user",
      message: "Enter database user:",
      default: "root",
    });

  if (!config.password)
    questions.push({
      type: "password",
      name: "password",
      message: "Enter database password:",
      mask: "*",
    });

  if (!config.dbName)
    questions.push({
      type: "input",
      name: "dbName",
      message: "Enter database name:",
    });

  if (!config.output)
    questions.push({
      type: "input",
      name: "output",
      message: "Enter output path:",
      default: defaultOutput,
    });

  // Allow additional questions from the caller
  if (customAskMissingParams) {
    customAskMissingParams(config, questions);
  }

  // If there are missing parameters, prompt the user
  if (questions.length > 0) {
    // @ts-ignore - Ignore TypeScript warning for dynamic question type
    const answers = (await inquirer.prompt(questions)) as PromptAnswers;
    const rawPort = config.port ?? answers.port;
    return {
      ...config,
      ...answers,
      port: rawPort === undefined ? undefined : Number.parseInt(String(rawPort), 10),
    };
  }

  return config;
};

/**
 * Retrieves configuration parameters from command-line arguments and environment variables.
 * If any required parameters are missing, prompts the user for input.
 * @param cmd - The command object containing CLI options.
 * @param defaultOutput - Default output directory.
 * @param customConfig - Optional function for additional configuration parameters.
 * @param customAskMissingParams - Optional function for additional prompts.
 * @returns A fully resolved configuration object.
 */
/**
 * Resolves the database port from the CLI flag, falling back to the environment.
 * @param cmdPort - Raw `--port` value from the command line.
 * @returns The parsed port number, or undefined when neither source is set.
 */
function resolvePort(cmdPort?: string): number | undefined {
  const raw = cmdPort ?? process.env.FORGE_SQL_ORM_PORT;
  return raw === undefined ? undefined : Number.parseInt(raw, 10);
}

const getConfig = async (
  cmd: CommandOptions,
  defaultOutput: string,
  customConfig?: () => Partial<CliConfig>,
  customAskMissingParams?: (cfg: CliConfig, questions: unknown[]) => void,
): Promise<CliConfig> => {
  let config = {
    host: cmd.host || process.env.FORGE_SQL_ORM_HOST,
    port: resolvePort(cmd.port),
    user: cmd.user || process.env.FORGE_SQL_ORM_USER,
    password: cmd.password || process.env.FORGE_SQL_ORM_PASSWORD,
    dbName: cmd.dbName || process.env.FORGE_SQL_ORM_DBNAME,
    output: cmd.output || process.env.FORGE_SQL_ORM_OUTPUT,
  };

  // Merge additional configurations if provided
  if (customConfig) {
    config = { ...config, ...customConfig() };
  }

  const conf = await askMissingParams(config, defaultOutput, customAskMissingParams);
  if (cmd.saveEnv) {
    saveEnvFile(conf);
  }
  return conf;
};

// 📌 Initialize CLI
export const program = new Command();
program.version("1.0.0");

// ✅ Command: Generate database models (Entities)
program
  .command("generate:model")
  .description("Generate Drizzle models from the database.")
  .option("--host <string>", "Database host")
  .option("--port <number>", "Database port")
  .option("--user <string>", "Database user")
  .option("--password <string>", "Database password")
  .option("--dbName <string>", "Database name")
  .option("--output <string>", "Output path for entities")
  .option("--versionField <string>", "Field name for versioning")
  .option("--saveEnv", "Save configuration to .env file")
  .action(async (cmd) => {
    const config = await getConfig(
      cmd,
      "./database/entities",
      () => ({
        versionField: cmd.versionField || process.env.FORGE_SQL_ORM_VERSIONFIELD,
      }),
      (cfg, questions: unknown[]) => {
        if (!cfg.versionField) {
          questions.push({
            type: "input",
            name: "versionField",
            message: "Enter the field name for versioning (leave empty to skip):",
            default: "",
          });
        }
      },
    );
    await generateModels(config as GenerateModelsOptions);
  });

// ✅ Command: Create initial database migration
program
  .command("migrations:create")
  .description("Generate an initial migration for the entire database.")
  .option("--host <string>", "Database host")
  .option("--port <number>", "Database port")
  .option("--user <string>", "Database user")
  .option("--password <string>", "Database password")
  .option("--dbName <string>", "Database name")
  .option("--output <string>", "Output path for migrations")
  .option("--force", "Force creation even if migrations exist")
  .option("--saveEnv", "Save configuration to .env file")
  .action(async (cmd) => {
    const config = await getConfig(cmd, "./database/migration", () => ({
      force: cmd.force || false,
    }));
    await createMigration(config as CreateMigrationOptions);
  });

// ✅ Command: Update migration for schema changes
program
  .command("migrations:update")
  .description("Generate a migration to update the database schema.")
  .option("--host <string>", "Database host")
  .option("--port <number>", "Database port")
  .option("--user <string>", "Database user")
  .option("--password <string>", "Database password")
  .option("--dbName <string>", "Database name")
  .option("--output <string>", "Output path for migrations")
  .option("--entitiesPath <string>", "Path to the folder containing entities")
  .option("--saveEnv", "Save configuration to .env file")
  .action(async (cmd) => {
    const config = await getConfig(
      cmd,
      "./database/migration",
      () => ({
        entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIESPATH,
      }),
      (cfg, questions: unknown[]) => {
        if (!cfg.entitiesPath)
          questions.push({
            type: "input",
            name: "entitiesPath",
            message: "Enter the path to entities:",
            default: "./database/entities",
          });
      },
    );
    await updateMigration(config as UpdateMigrationOptions);
  });

// ✅ Command: Drop all migrations
program
  .command("migrations:drop")
  .description("Generate a migration to drop all tables and clear migrations history.")
  .option("--host <string>", "Database host")
  .option("--port <number>", "Database port")
  .option("--user <string>", "Database user")
  .option("--password <string>", "Database password")
  .option("--dbName <string>", "Database name")
  .option("--output <string>", "Output path for migrations")
  .option("--entitiesPath <string>", "Path to the folder containing entities")
  .option("--saveEnv", "Save configuration to .env file")
  .action(async (cmd) => {
    const config = await getConfig(
      cmd,
      "./database/migration",
      () => ({
        entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIESPATH,
      }),
      (cfg, questions: unknown[]) => {
        if (!cfg.entitiesPath)
          questions.push({
            type: "input",
            name: "entitiesPath",
            message: "Enter the path to entities:",
            default: "./database/entities",
          });
      },
    );
    await dropMigration(config as DropMigrationOptions);
  });

// ✅ Command: Apply DB schema directly from Drizzle models
program
  .command("schema:create")
  .description("Create/update database schema directly from Drizzle models.")
  .option("--host <string>", "Database host")
  .option("--port <number>", "Database port")
  .option("--user <string>", "Database user")
  .option("--password <string>", "Database password")
  .option("--dbName <string>", "Database name")
  .option("--entitiesPath <string>", "Path to the folder containing entities")
  .option("--saveEnv", "Save configuration to .env file")
  .action(async (cmd) => {
    const config = await getConfig(
      cmd,
      "./database/entities",
      () => ({
        entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIESPATH,
      }),
      (cfg, questions: unknown[]) => {
        if (!cfg.entitiesPath)
          questions.push({
            type: "input",
            name: "entitiesPath",
            message: "Enter the path to entities:",
            default: "./database/entities",
          });
      },
    );
    await createSchema(config as CreateSchemaOptions);
  });

// 🔥 Execute CLI
program.parse(process.argv);