import { assertEquals, assertThrows } from "@std/assert";
import Logger from "../lib/logger.ts";
import {
  clearCapturedLogs,
  getCapturedLogs,
  setupMocks,
} from "./helpers/logger-test-helpers.js";

// Setup and teardown for all tests
setupMocks();

Deno.test("Logger Level Management - Level Setting and Getting - should change log level with level() method", () => {
  const logger = new Logger();
  logger.level("debug");
  assertEquals(logger.options.level, "debug");
});

Deno.test("Logger Level Management - Level Setting and Getting - should return current level when called without arguments", () => {
  const logger = new Logger({ level: "debug" });
  assertEquals(logger.level(), "debug");
});

Deno.test("Logger Level Management - Level Setting and Getting - should return new level when setting level", () => {
  const logger = new Logger();
  const result = logger.level("error");
  assertEquals(result, "error");
  assertEquals(logger.options.level, "error");
});

Deno.test("Logger Level Management - Level Setting and Getting - should throw error for invalid log level", () => {
  const logger = new Logger();
  assertThrows(
    () => {
      logger.level("invalid");
    },
    Error,
    "Invalid log level: invalid",
  );
});

Deno.test("Logger Level Management - Level Setting and Getting - should allow method chaining after setting level", () => {
  const logger = new Logger();
  // This should not throw and should return a level
  const result = logger.level("warn");
  assertEquals(result, "warn");
  assertEquals(typeof result, "string");
});

Deno.test("Logger Level Management - setLevel Method - should have setLevel method as alias", () => {
  const logger = new Logger();
  assertEquals(typeof logger.setLevel, "function");
});

Deno.test("Logger Level Management - setLevel Method - should set level correctly with setLevel method", () => {
  const logger = new Logger();
  const result = logger.setLevel("debug");
  assertEquals(result, "debug");
  assertEquals(logger.options.level, "debug");
});

Deno.test("Logger Level Management - setLevel Method - should return current level with setLevel when no args", () => {
  const logger = new Logger({ level: "warn" });
  const result = logger.setLevel();
  assertEquals(result, "warn");
});

Deno.test("Logger Level Management - setLevel Method - should throw error for invalid level in setLevel", () => {
  const logger = new Logger();
  assertThrows(
    () => {
      logger.setLevel("invalid");
    },
    Error,
    "Invalid log level: invalid",
  );
});

Deno.test("Logger Level Management - setLevel Method - should maintain consistency between level() and setLevel()", () => {
  const logger = new Logger();

  logger.level("error");
  assertEquals(logger.setLevel(), "error");

  logger.setLevel("debug");
  assertEquals(logger.level(), "debug");
});

Deno.test("Logger Level Management - setLevel Method - should support fluent interface pattern", () => {
  const logger = new Logger();

  // This demonstrates the fluent interface working
  const currentLevel = logger.level("warn");
  assertEquals(currentLevel, "warn");

  // Both methods should return the current level for chaining
  assertEquals(logger.level("info"), "info");
  assertEquals(logger.setLevel("debug"), "debug");
});

Deno.test("Logger Level Management - Log Level Filtering - should filter debug messages when level is info", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "info" });
  logger.debug("debug message");
  assertEquals(getCapturedLogs().length, 0);
});

Deno.test("Logger Level Management - Log Level Filtering - should show info messages when level is info", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "info" });
  logger.info("info message");
  assertEquals(getCapturedLogs().length, 1);
});

Deno.test("Logger Level Management - Log Level Filtering - should show error messages at any level", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "error" });
  logger.error("error message");
  assertEquals(getCapturedLogs().length, 1);
});

Deno.test("Logger Level Management - Log Level Filtering - should filter warn and info when level is error", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "error" });
  logger.warn("warn message");
  logger.info("info message");
  assertEquals(getCapturedLogs().length, 0);
});

Deno.test("Logger Level Management - Log Level Filtering - should show all messages when level is debug", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "debug" });
  logger.error("error message");
  logger.warn("warn message");
  logger.info("info message");
  logger.debug("debug message");
  assertEquals(getCapturedLogs().length, 4);
});

Deno.test("Logger Level Management - Log Level Filtering - should show warn and above when level is warn", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "warn" });
  logger.error("error message");
  logger.warn("warn message");
  logger.info("info message");
  logger.debug("debug message");
  assertEquals(getCapturedLogs().length, 2);
});

Deno.test("Logger Level Management - Silent Level - should suppress all output when level is silent", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "silent" });

  logger.error("error message");
  logger.warn("warn message");
  logger.info("info message");
  logger.debug("debug message");

  // No messages should be logged
  assertEquals(getCapturedLogs().length, 0);
});

Deno.test("Logger Level Management - Silent Level - should allow setting level to silent", () => {
  const logger = new Logger();
  const result = logger.level("silent");
  assertEquals(result, "silent");
  assertEquals(logger.options.level, "silent");
});

Deno.test("Logger Level Management - Silent Level - should work with setLevel for silent level", () => {
  const logger = new Logger();
  const result = logger.setLevel("silent");
  assertEquals(result, "silent");
  assertEquals(logger.options.level, "silent");
});

Deno.test("Logger Level Management - Silent Level - should remain silent after multiple log attempts", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "silent" });

  // Try logging multiple times
  for (let i = 0; i < 5; i++) {
    logger.error(`error ${i}`);
    logger.warn(`warn ${i}`);
    logger.info(`info ${i}`);
    logger.debug(`debug ${i}`);
  }

  // Still no output
  assertEquals(getCapturedLogs().length, 0);
});

Deno.test("Logger Level Management - Dynamic Level Changes - should respect level changes during runtime", () => {
  clearCapturedLogs();
  const logger = new Logger({ level: "error" });

  // Should not log at info level
  logger.info("info message 1");
  assertEquals(getCapturedLogs().length, 0);

  // Change to info level
  logger.level("info");

  // Should now log info messages
  logger.info("info message 2");
  assertEquals(getCapturedLogs().length, 1);

  // Change to silent
  logger.level("silent");

  // Should not log anything
  logger.error("error message");
  assertEquals(getCapturedLogs().length, 1); // Still just the previous info message
});