import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { TelemetryClient } from "../src/client.js";
import { TelemetryConfig } from "../src/config.js";
import {
  TaskCompletionEvent,
  TaskType,
  Complexity,
  Harness,
  Provider,
  Outcome,
} from "../src/types/events.js";
import {
  PredictionQuery,
  PredictionResponse,
} from "../src/types/predictions.js";

function makeConfig(overrides: Partial<TelemetryConfig> = {}): TelemetryConfig {
  return {
    serverUrl: "https://tel.example.com",
    apiKey: "a".repeat(64),
    instanceId: "test-instance",
    submitIntervalMs: 60_000,
    maxQueueSize: 100,
    batchSize: 10,
    requestTimeoutMs: 5000,
    dryRun: true, // Use dryRun by default in tests
    ...overrides,
  };
}

function makeEvent(id = "evt-1"): TaskCompletionEvent {
  return {
    instance_id: "test-instance",
    event_id: id,
    schema_version: "1.0",
    timestamp: new Date().toISOString(),
    task_duration_ms: 5000,
    task_type: TaskType.IMPLEMENTATION,
    complexity: Complexity.MEDIUM,
    harness: Harness.CLAUDE_CODE,
    model: "claude-3-opus",
    provider: Provider.ANTHROPIC,
    estimated_input_tokens: 1000,
    estimated_output_tokens: 500,
    actual_input_tokens: 1100,
    actual_output_tokens: 550,
    estimated_cost_usd_micros: 50000,
    actual_cost_usd_micros: 55000,
    quality_gate_passed: true,
    quality_gates_run: [],
    quality_gates_failed: [],
    context_compactions: 0,
    context_rotations: 0,
    context_utilization_final: 0.5,
    outcome: Outcome.SUCCESS,
    retry_count: 0,
  };
}

function makeQuery(): PredictionQuery {
  return {
    task_type: TaskType.IMPLEMENTATION,
    model: "claude-3-opus",
    provider: Provider.ANTHROPIC,
    complexity: Complexity.MEDIUM,
  };
}

function makePredictionResponse(): PredictionResponse {
  return {
    prediction: {
      input_tokens: { p10: 500, p25: 750, median: 1000, p75: 1500, p90: 2000 },
      output_tokens: { p10: 200, p25: 350, median: 500, p75: 750, p90: 1000 },
      cost_usd_micros: { median: 50000 },
      duration_ms: { median: 30000 },
      correction_factors: { input: 1.1, output: 1.05 },
      quality: { gate_pass_rate: 0.85, success_rate: 0.9 },
    },
    metadata: {
      sample_size: 100,
      fallback_level: 0,
      confidence: "high",
      last_updated: new Date().toISOString(),
      cache_hit: false,
    },
  };
}

describe("TelemetryClient", () => {
  let fetchSpy: ReturnType<typeof vi.fn>;

  beforeEach(() => {
    vi.useFakeTimers();
    fetchSpy = vi.fn();
    vi.stubGlobal("fetch", fetchSpy);
  });

  afterEach(() => {
    vi.useRealTimers();
    vi.unstubAllGlobals();
  });

  describe("start/stop lifecycle", () => {
    it("should start and stop cleanly", async () => {
      const client = new TelemetryClient(makeConfig());

      expect(client.isRunning).toBe(false);
      client.start();
      expect(client.isRunning).toBe(true);

      await client.stop();
      expect(client.isRunning).toBe(false);
    });

    it("should be idempotent on start", () => {
      const client = new TelemetryClient(makeConfig());
      client.start();
      client.start(); // Should not throw or create double intervals
      expect(client.isRunning).toBe(true);
    });

    it("should be idempotent on stop", async () => {
      const client = new TelemetryClient(makeConfig());
      await client.stop();
      await client.stop(); // Should not throw
      expect(client.isRunning).toBe(false);
    });

    it("should flush events on stop", async () => {
      const client = new TelemetryClient(makeConfig());
      client.start();

      client.track(makeEvent("e1"));
      client.track(makeEvent("e2"));
      expect(client.queueSize).toBe(2);

      await client.stop();
      // In dryRun mode, flush succeeds and queue should be empty
      expect(client.queueSize).toBe(0);
    });
  });

  describe("track()", () => {
    it("should queue events", () => {
      const client = new TelemetryClient(makeConfig());
      client.track(makeEvent("e1"));
      client.track(makeEvent("e2"));
      expect(client.queueSize).toBe(2);
    });

    it("should silently drop events when disabled", () => {
      const client = new TelemetryClient(makeConfig({ enabled: false }));
      client.track(makeEvent());
      expect(client.queueSize).toBe(0);
    });

    it("should never throw even on internal error", () => {
      const errorFn = vi.fn();
      const client = new TelemetryClient(
        makeConfig({ onError: errorFn, maxQueueSize: 0 }),
      );

      // This should not throw. maxQueueSize of 0 could cause issues
      // but track() is designed to catch everything.
      expect(() => client.track(makeEvent())).not.toThrow();
    });
  });

  describe("predictions", () => {
    it("should return null for uncached prediction", () => {
      const client = new TelemetryClient(makeConfig());
      const result = client.getPrediction(makeQuery());
      expect(result).toBeNull();
    });

    it("should return cached prediction after refresh", async () => {
      const predictionResponse = makePredictionResponse();
      fetchSpy.mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: () =>
          Promise.resolve({
            results: [predictionResponse],
          }),
      });

      const client = new TelemetryClient(makeConfig({ dryRun: false }));
      const query = makeQuery();

      await client.refreshPredictions([query]);

      const result = client.getPrediction(query);
      expect(result).toEqual(predictionResponse);
    });

    it("should handle refresh error gracefully", async () => {
      fetchSpy.mockRejectedValueOnce(new Error("Network error"));

      const errorFn = vi.fn();
      const client = new TelemetryClient(
        makeConfig({ dryRun: false, onError: errorFn }),
      );

      // Should not throw
      await client.refreshPredictions([makeQuery()]);
      expect(errorFn).toHaveBeenCalledWith(expect.any(Error));
    });

    it("should handle non-ok HTTP response on refresh", async () => {
      fetchSpy.mockResolvedValueOnce({
        ok: false,
        status: 500,
        statusText: "Internal Server Error",
      });

      const errorFn = vi.fn();
      const client = new TelemetryClient(
        makeConfig({ dryRun: false, onError: errorFn }),
      );

      await client.refreshPredictions([makeQuery()]);
      expect(errorFn).toHaveBeenCalledWith(expect.any(Error));
    });
  });

  describe("background flush", () => {
    it("should trigger flush on interval", async () => {
      const client = new TelemetryClient(
        makeConfig({ submitIntervalMs: 10_000 }),
      );
      client.start();

      client.track(makeEvent("e1"));
      expect(client.queueSize).toBe(1);

      // Advance past submit interval
      await vi.advanceTimersByTimeAsync(11_000);

      // In dryRun mode, events should be flushed
      expect(client.queueSize).toBe(0);

      await client.stop();
    });
  });

  describe("flush error handling", () => {
    it("should re-enqueue events on submit failure", async () => {
      // Use non-dryRun mode to actually hit the submitter
      fetchSpy.mockResolvedValueOnce({
        ok: false,
        status: 500,
        statusText: "Internal Server Error",
      });

      const errorFn = vi.fn();
      const client = new TelemetryClient(
        makeConfig({ dryRun: false, maxRetries: 0, onError: errorFn }),
      );

      client.track(makeEvent("e1"));
      expect(client.queueSize).toBe(1);

      // Start and trigger flush
      client.start();
      await vi.advanceTimersByTimeAsync(70_000);

      // Events should be re-enqueued after failure
      expect(client.queueSize).toBeGreaterThan(0);

      await client.stop();
    });

    it("should handle onError callback that throws", async () => {
      const throwingErrorFn = () => {
        throw new Error("Error handler broke");
      };
      const client = new TelemetryClient(
        makeConfig({ onError: throwingErrorFn, enabled: false }),
      );

      // This should not throw even though onError throws
      // Force an error path by calling track when disabled (no error),
      // but we can test via refreshPredictions
      fetchSpy.mockRejectedValueOnce(new Error("fail"));
      await expect(
        client.refreshPredictions([makeQuery()]),
      ).resolves.not.toThrow();
    });
  });

  describe("event builder", () => {
    it("should expose an event builder", () => {
      const client = new TelemetryClient(makeConfig());
      expect(client.eventBuilder).toBeDefined();

      const event = client.eventBuilder.build({
        task_duration_ms: 1000,
        task_type: TaskType.TESTING,
        complexity: Complexity.LOW,
        harness: Harness.AIDER,
        model: "gpt-4",
        provider: Provider.OPENAI,
        estimated_input_tokens: 100,
        estimated_output_tokens: 50,
        actual_input_tokens: 100,
        actual_output_tokens: 50,
        estimated_cost_usd_micros: 1000,
        actual_cost_usd_micros: 1000,
        quality_gate_passed: true,
        quality_gates_run: [],
        quality_gates_failed: [],
        context_compactions: 0,
        context_rotations: 0,
        context_utilization_final: 0.3,
        outcome: Outcome.SUCCESS,
        retry_count: 0,
      });

      expect(event.instance_id).toBe("test-instance");
      expect(event.schema_version).toBe("1.0");
    });
  });
});