/**
 * Unit tests for core/config.ts
 *
 * Tests configuration loading and management including:
 * - Path expansion (~/path)
 * - Directory creation
 * - Config file loading
 * - Environment variable overrides
 * - Schema validation
 * - Default config generation
 */

import { describe, test, expect, beforeEach, afterEach } from "bun:test";
import { existsSync, mkdirSync, writeFileSync, rmSync } from "fs";
import { join } from "path";
import {
  createTempDir,
  cleanupTempDir,
  createTempFile,
  mockEnv,
  testLog,
} from "../../helpers/test-utils.ts";

// We need to import the functions we're testing
// Note: We'll use dynamic imports to allow mocking
import { expandPath, generateDefaultConfig } from "../../../src/core/config.ts";
import { ConfigSchema, DEFAULT_CONFIG } from "../../../src/core/types.ts";

describe("core/config.ts", () => {
  describe("expandPath", () => {
    test("expands ~ to home directory", () => {
      testLog.step(1, "Testing tilde expansion");
      const result = expandPath("~/Documents/test");
      const home = process.env.HOME || "";

      expect(result).not.toContain("~");
      expect(result).toContain("Documents/test");
      expect(result.startsWith(home)).toBe(true);
      testLog.info(`Expanded: ~/Documents/test -> ${result}`);
    });

    test("returns unchanged if no tilde prefix", () => {
      const input = "/absolute/path/file.txt";
      const result = expandPath(input);

      expect(result).toBe(input);
    });

    test("handles ~ alone", () => {
      const result = expandPath("~/");
      const home = process.env.HOME || "";

      expect(result).toBe(home);
    });

    test("handles empty string", () => {
      const result = expandPath("");
      expect(result).toBe("");
    });

    test("does not expand ~ in middle of path", () => {
      const input = "/some/path~/file";
      const result = expandPath(input);

      expect(result).toBe(input);
    });

    test("handles relative paths", () => {
      const input = "./relative/path";
      const result = expandPath(input);

      expect(result).toBe(input);
    });
  });

  describe("ConfigSchema validation", () => {
    test("validates default config", () => {
      testLog.step(1, "Validating default configuration");
      const result = ConfigSchema.safeParse(DEFAULT_CONFIG);

      expect(result.success).toBe(true);
      testLog.info("Default config is valid");
    });

    test("validates complete valid config", () => {
      const validConfig = {
        output_dir: "~/Audio/speak",
        model: "mlx-community/chatterbox-turbo-8bit",
        temperature: 0.7,
        speed: 1.2,
        markdown_mode: "smart",
        code_blocks: "skip",
        voice: "narrator",
        daemon: true,
        update_check: false,
        log_level: "debug",
      };

      const result = ConfigSchema.safeParse(validConfig);

      expect(result.success).toBe(true);
      if (result.success) {
        expect(result.data.temperature).toBe(0.7);
        expect(result.data.speed).toBe(1.2);
        expect(result.data.markdown_mode).toBe("smart");
      }
    });

    test("rejects invalid temperature (too high)", () => {
      testLog.step(1, "Testing temperature validation");
      const config = {
        ...DEFAULT_CONFIG,
        temperature: 2.0, // Max is 1
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(false);
      testLog.info("Invalid temperature correctly rejected");
    });

    test("rejects invalid temperature (negative)", () => {
      const config = {
        ...DEFAULT_CONFIG,
        temperature: -0.5, // Min is 0
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(false);
    });

    test("rejects invalid speed (too high)", () => {
      const config = {
        ...DEFAULT_CONFIG,
        speed: 3.0, // Max is 2
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(false);
    });

    test("rejects invalid speed (negative)", () => {
      const config = {
        ...DEFAULT_CONFIG,
        speed: -1, // Min is 0
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(false);
    });

    test("rejects invalid markdown_mode", () => {
      const config = {
        ...DEFAULT_CONFIG,
        markdown_mode: "invalid",
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(false);
    });

    test("accepts valid markdown_mode values", () => {
      for (const mode of ["plain", "smart"]) {
        const config = { ...DEFAULT_CONFIG, markdown_mode: mode };
        const result = ConfigSchema.safeParse(config);
        expect(result.success).toBe(true);
      }
    });

    test("rejects invalid code_blocks mode", () => {
      const config = {
        ...DEFAULT_CONFIG,
        code_blocks: "invalid",
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(false);
    });

    test("accepts valid code_blocks values", () => {
      for (const mode of ["read", "skip", "placeholder"]) {
        const config = { ...DEFAULT_CONFIG, code_blocks: mode };
        const result = ConfigSchema.safeParse(config);
        expect(result.success).toBe(true);
      }
    });

    test("rejects invalid log_level", () => {
      const config = {
        ...DEFAULT_CONFIG,
        log_level: "verbose",
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(false);
    });

    test("accepts valid log_level values", () => {
      for (const level of ["debug", "info", "warn", "error"]) {
        const config = { ...DEFAULT_CONFIG, log_level: level };
        const result = ConfigSchema.safeParse(config);
        expect(result.success).toBe(true);
      }
    });

    test("voice is optional", () => {
      const config = {
        ...DEFAULT_CONFIG,
        voice: undefined,
      };

      const result = ConfigSchema.safeParse(config);

      expect(result.success).toBe(true);
    });

    test("applies defaults for missing values", () => {
      testLog.step(1, "Testing default value application");
      const minimal = {};
      const result = ConfigSchema.safeParse(minimal);

      expect(result.success).toBe(true);
      if (result.success) {
        expect(result.data.output_dir).toBe("~/Audio/speak");
        expect(result.data.model).toBe("mlx-community/chatterbox-turbo-8bit");
        expect(result.data.temperature).toBe(0.5);
        expect(result.data.speed).toBe(1.0);
        expect(result.data.markdown_mode).toBe("plain");
        expect(result.data.code_blocks).toBe("read");
        expect(result.data.daemon).toBe(false);
        expect(result.data.log_level).toBe("info");
      }
      testLog.info("Defaults applied correctly");
    });
  });

  describe("DEFAULT_CONFIG", () => {
    test("has expected structure", () => {
      expect(DEFAULT_CONFIG).toHaveProperty("output_dir");
      expect(DEFAULT_CONFIG).toHaveProperty("model");
      expect(DEFAULT_CONFIG).toHaveProperty("temperature");
      expect(DEFAULT_CONFIG).toHaveProperty("speed");
      expect(DEFAULT_CONFIG).toHaveProperty("markdown_mode");
      expect(DEFAULT_CONFIG).toHaveProperty("code_blocks");
      expect(DEFAULT_CONFIG).toHaveProperty("daemon");
      expect(DEFAULT_CONFIG).toHaveProperty("log_level");
    });

    test("has sensible default values", () => {
      expect(DEFAULT_CONFIG.temperature).toBeGreaterThanOrEqual(0);
      expect(DEFAULT_CONFIG.temperature).toBeLessThanOrEqual(1);
      expect(DEFAULT_CONFIG.speed).toBeGreaterThanOrEqual(0);
      expect(DEFAULT_CONFIG.speed).toBeLessThanOrEqual(2);
      expect(DEFAULT_CONFIG.daemon).toBe(false);
    });
  });

  describe("generateDefaultConfig", () => {
    test("generates valid TOML content", () => {
      testLog.step(1, "Testing default config generation");
      const content = generateDefaultConfig();

      expect(content).toContain("output_dir");
      expect(content).toContain("model");
      expect(content).toContain("temperature");
      expect(content).toContain("speed");
      expect(content).toContain("markdown_mode");
      expect(content).toContain("code_blocks");
      expect(content).toContain("daemon");
      expect(content).toContain("log_level");
      testLog.info("Generated config contains all expected keys");
    });

    test("includes comments", () => {
      const content = generateDefaultConfig();

      expect(content).toContain("#");
      expect(content).toContain("Location:");
    });

    test("can be parsed as TOML", async () => {
      testLog.step(1, "Verifying generated config is valid TOML");
      const TOML = await import("@iarna/toml");
      const content = generateDefaultConfig();

      // Should not throw
      const parsed = TOML.parse(content);

      expect(parsed.output_dir).toBeDefined();
      expect(parsed.model).toBeDefined();
      testLog.info("Generated config parses as valid TOML");
    });
  });

  describe("environment variable handling", () => {
    let restoreEnv: () => void;

    afterEach(() => {
      if (restoreEnv) restoreEnv();
    });

    test("SPEAK_OUTPUT_DIR is recognized", () => {
      restoreEnv = mockEnv({ SPEAK_OUTPUT_DIR: "/custom/output" });
      // The actual loading would need loadConfig() which depends on file system
      // For unit testing, we verify the env var is set correctly
      expect(process.env.SPEAK_OUTPUT_DIR).toBe("/custom/output");
    });

    test("SPEAK_MODEL is recognized", () => {
      restoreEnv = mockEnv({ SPEAK_MODEL: "mlx-community/chatterbox-turbo-fp16" });
      expect(process.env.SPEAK_MODEL).toBe("mlx-community/chatterbox-turbo-fp16");
    });

    test("SPEAK_TEMPERATURE is recognized", () => {
      restoreEnv = mockEnv({ SPEAK_TEMPERATURE: "0.8" });
      expect(process.env.SPEAK_TEMPERATURE).toBe("0.8");
    });

    test("SPEAK_SPEED is recognized", () => {
      restoreEnv = mockEnv({ SPEAK_SPEED: "1.5" });
      expect(process.env.SPEAK_SPEED).toBe("1.5");
    });

    test("SPEAK_DAEMON boolean handling", () => {
      restoreEnv = mockEnv({ SPEAK_DAEMON: "true" });
      expect(process.env.SPEAK_DAEMON).toBe("true");
    });

    test("SPEAK_LOG_LEVEL is recognized", () => {
      restoreEnv = mockEnv({ SPEAK_LOG_LEVEL: "debug" });
      expect(process.env.SPEAK_LOG_LEVEL).toBe("debug");
    });
  });

  describe("path constants", () => {
    test("CHATTER_DIR uses home directory", async () => {
      const { CHATTER_DIR } = await import("../../../src/core/config.ts");
      const home = process.env.HOME || "";

      expect(CHATTER_DIR.startsWith(home)).toBe(true);
      expect(CHATTER_DIR).toContain(".chatter");
    });

    test("CONFIG_PATH is in CHATTER_DIR", async () => {
      const { CHATTER_DIR, CONFIG_PATH } = await import("../../../src/core/config.ts");

      expect(CONFIG_PATH.startsWith(CHATTER_DIR)).toBe(true);
      expect(CONFIG_PATH).toContain("config.toml");
    });

    test("SOCKET_PATH is in CHATTER_DIR", async () => {
      const { CHATTER_DIR, SOCKET_PATH } = await import("../../../src/core/config.ts");

      expect(SOCKET_PATH.startsWith(CHATTER_DIR)).toBe(true);
      expect(SOCKET_PATH).toContain("speak.sock");
    });

    test("VENV_DIR is in CHATTER_DIR", async () => {
      const { CHATTER_DIR, VENV_DIR } = await import("../../../src/core/config.ts");

      expect(VENV_DIR.startsWith(CHATTER_DIR)).toBe(true);
      expect(VENV_DIR).toContain("env");
    });

    test("VENV_PYTHON is in VENV_DIR", async () => {
      const { VENV_DIR, VENV_PYTHON } = await import("../../../src/core/config.ts");

      expect(VENV_PYTHON.startsWith(VENV_DIR)).toBe(true);
      expect(VENV_PYTHON).toContain("python3");
    });

    test("LOGS_DIR is in CHATTER_DIR", async () => {
      const { CHATTER_DIR, LOGS_DIR } = await import("../../../src/core/config.ts");

      expect(LOGS_DIR.startsWith(CHATTER_DIR)).toBe(true);
      expect(LOGS_DIR).toContain("logs");
    });
  });

  describe("edge cases", () => {
    test("handles partial config with just output_dir", () => {
      const partial = { output_dir: "~/custom" };
      const result = ConfigSchema.safeParse(partial);

      expect(result.success).toBe(true);
      if (result.success) {
        expect(result.data.output_dir).toBe("~/custom");
        expect(result.data.model).toBe(DEFAULT_CONFIG.model);
      }
    });

    test("handles config with extra unknown fields", () => {
      const withExtra = {
        ...DEFAULT_CONFIG,
        unknown_field: "value",
        another_unknown: 123,
      };

      // Zod strips unknown by default in strict mode
      // In passthrough mode it would keep them
      const result = ConfigSchema.safeParse(withExtra);
      expect(result.success).toBe(true);
    });

    test("handles boundary values for temperature", () => {
      // Temperature at boundaries
      const atZero = { ...DEFAULT_CONFIG, temperature: 0 };
      const atOne = { ...DEFAULT_CONFIG, temperature: 1 };

      expect(ConfigSchema.safeParse(atZero).success).toBe(true);
      expect(ConfigSchema.safeParse(atOne).success).toBe(true);
    });

    test("handles boundary values for speed", () => {
      // Speed at boundaries
      const atZero = { ...DEFAULT_CONFIG, speed: 0 };
      const atTwo = { ...DEFAULT_CONFIG, speed: 2 };

      expect(ConfigSchema.safeParse(atZero).success).toBe(true);
      expect(ConfigSchema.safeParse(atTwo).success).toBe(true);
    });
  });
});