import { assert, assertEquals } 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 Robustness - Edge Cases and Data Handling - should not crash on logging errors", () => {
  clearCapturedLogs();
  const logger = new Logger();

  // This should not throw
  logger.info("test message");
});

Deno.test("Logger Robustness - Edge Cases and Data Handling - should handle undefined and null messages gracefully", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "json" });

  // These should not crash
  logger.info(undefined);
  logger.info(null);

  const logs = getCapturedLogs();
  assertEquals(logs.length, 2);

  const parsed1 = JSON.parse(logs[0]);
  const parsed2 = JSON.parse(logs[1]);

  assertEquals(parsed1.msg, "undefined");
  assertEquals(parsed2.msg, "null");
});

Deno.test("Logger Robustness - Edge Cases and Data Handling - should handle extremely large messages", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "json" });
  const hugeMessage = "x".repeat(100000);

  logger.info(hugeMessage);

  const parsed = JSON.parse(getCapturedLogs()[0]);
  assertEquals(parsed.msg, hugeMessage);
});

Deno.test("Logger Robustness - Edge Cases and Data Handling - should handle circular objects in message formatting", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "json" });

  const circular = { name: "test" };
  circular.self = circular;

  logger.info("Circular: %j", circular);

  // Should still log something
  assertEquals(getCapturedLogs().length, 1);
});

Deno.test("Logger Robustness - Performance and Memory - should handle rapid consecutive logging without issues", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "json" });

  for (let i = 0; i < 1000; i++) {
    logger.info(`rapid message ${i}`);
  }

  assertEquals(getCapturedLogs().length, 1000);
});

Deno.test("Logger Robustness - Performance and Memory - should handle repeated logging operations efficiently", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "simple" });

  const startTime = Date.now();

  // Log a reasonable number of messages
  for (let i = 0; i < 500; i++) {
    logger.info(`performance test message ${i}`);
  }

  const endTime = Date.now();
  const duration = endTime - startTime;

  // Should complete within reasonable time (adjust threshold as needed)
  assert(duration < 5000, `Logging took too long: ${duration}ms`);
  assertEquals(getCapturedLogs().length, 500);
});

Deno.test("Logger Robustness - Performance and Memory - should handle mixed format types in rapid succession", () => {
  clearCapturedLogs();
  const jsonLogger = new Logger({ format: "json" });
  const simpleLogger = new Logger({ format: "simple" });

  for (let i = 0; i < 50; i++) {
    jsonLogger.info(`json message ${i}`);
    simpleLogger.info(`simple message ${i}`);
  }

  assertEquals(getCapturedLogs().length, 100);
});

Deno.test("Logger Robustness - Complex Data Structures - should handle deeply nested objects", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "json" });

  const deepObject = {
    level1: { level2: { level3: { level4: { value: "deep" } } } },
  };

  logger.info("Deep object: %j", deepObject);

  assertEquals(getCapturedLogs().length, 1);
});

Deno.test("Logger Robustness - Complex Data Structures - should handle arrays with mixed data types", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "json" });

  const mixedArray = [
    1,
    "string",
    { obj: true },
    [1, 2, 3],
    null,
    undefined,
  ];

  logger.info("Mixed array: %j", mixedArray);

  assertEquals(getCapturedLogs().length, 1);
});

Deno.test("Logger Robustness - Complex Data Structures - should handle special characters and unicode", () => {
  clearCapturedLogs();
  const logger = new Logger({ format: "json" });

  const specialMessage = "Special chars: \n\t\r\\\"'🚀 Unicode: こんにちは";

  logger.info(specialMessage);

  const parsed = JSON.parse(getCapturedLogs()[0]);
  assertEquals(parsed.msg, specialMessage);
});