import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
import { RtmpPush } from "../src/RtmpPush.js";

// Mock the child_process module
const mockProcess = {
  stdout: { on: mock(() => {}) },
  stderr: { on: mock(() => {}) },
  on: mock(() => {}),
  kill: mock(() => {}),
  killed: false
};

const mockSpawn = mock(() => mockProcess);

mock.module("node:child_process", () => ({
  spawn: mockSpawn
}));

describe("RtmpPush", () => {
  let rtmpPush: RtmpPush;
  const mockMediaSourceUri = "https://example.com/test-video.ts";
  const mockRtmpIngestUri = "rtmp://ingest.example.com:80/ingest";

  beforeEach(() => {
    rtmpPush = new RtmpPush(mockMediaSourceUri, mockRtmpIngestUri);
    // Reset mock calls
    mockSpawn.mockClear();
    mockProcess.stdout.on.mockClear();
    mockProcess.stderr.on.mockClear();
    mockProcess.on.mockClear();
    mockProcess.kill.mockClear();
  });

  afterEach(() => {
    // Clean up any running processes
    if (rtmpPush.isRunning()) {
      rtmpPush.stop();
    }
  });

  describe("Constructor", () => {
    it("should create instance with correct properties", () => {
      expect(rtmpPush).toBeInstanceOf(RtmpPush);
      expect(rtmpPush.mediaSourceUri).toBe(mockMediaSourceUri);
      expect(rtmpPush.rtmpIngestUri).toBe(mockRtmpIngestUri);
    });

    it("should handle empty strings", () => {
      const emptyRtmpPush = new RtmpPush("", "");
      expect(emptyRtmpPush.mediaSourceUri).toBe("");
      expect(emptyRtmpPush.rtmpIngestUri).toBe("");
    });
  });

  describe("Getters", () => {
    it("should return correct mediaSourceUri", () => {
      expect(rtmpPush.mediaSourceUri).toBe(mockMediaSourceUri);
    });

    it("should return correct rtmpIngestUri", () => {
      expect(rtmpPush.rtmpIngestUri).toBe(mockRtmpIngestUri);
    });

    it("should return immutable values", () => {
      const originalMediaUri = rtmpPush.mediaSourceUri;
      const originalRtmpUri = rtmpPush.rtmpIngestUri;
      
      // These should not change the internal state
      expect(rtmpPush.mediaSourceUri).toBe(originalMediaUri);
      expect(rtmpPush.rtmpIngestUri).toBe(originalRtmpUri);
    });
  });

  describe("start() method", () => {
    it("should start RTMP push process with correct parameters", () => {
      const streamKey = "test-stream-123";
      const capabilities = ["h264", "aac"];
      
      const result = rtmpPush.start(streamKey, capabilities);
      
      expect(result).toBe(rtmpPush);
      expect(rtmpPush.isRunning()).toBe(true);
    });

    it("should construct correct ffmpeg command", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264", "aac"];
      
      rtmpPush.start(streamKey, capabilities);
      
      expect(mockSpawn).toHaveBeenCalledWith(
        "ffmpeg",
        expect.arrayContaining([
          "-re",
          "-hide_banner",
          "-stream_loop", "-1",
          "-y",
          "-flags", "low_delay",
          "-fflags", "+nobuffer+flush_packets",
          "-i", mockMediaSourceUri,
          "-c:a", "copy",
          "-c:v", "copy",
          "-flush_packets", "1",
          "-copyts",
          "-f", "flv"
        ])
      );
    });

    it("should construct correct ingest URI", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264", "aac"];
      
      rtmpPush.start(streamKey, capabilities);
      
      const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
      
      expect(mockSpawn).toHaveBeenCalledWith(
        "ffmpeg",
        expect.arrayContaining([expectedIngestUri])
      );
    });

    it("should handle empty capabilities array", () => {
      const streamKey = "test-stream";
      const capabilities: string[] = [];
      
      rtmpPush.start(streamKey, capabilities);
      
      const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=;tags=`;
      
      expect(mockSpawn).toHaveBeenCalledWith(
        "ffmpeg",
        expect.arrayContaining([expectedIngestUri])
      );
    });

    it("should handle single capability", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      
      const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=h264;tags=`;
      
      expect(mockSpawn).toHaveBeenCalledWith(
        "ffmpeg",
        expect.arrayContaining([expectedIngestUri])
      );
    });

    it("should set up process event handlers", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      
      expect(mockProcess.stdout.on).toHaveBeenCalledWith("data", expect.any(Function));
      expect(mockProcess.stderr.on).toHaveBeenCalledWith("data", expect.any(Function));
      expect(mockProcess.on).toHaveBeenCalledWith("close", expect.any(Function));
      expect(mockProcess.on).toHaveBeenCalledWith("error", expect.any(Function));
    });

    it("should be chainable", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      const result = rtmpPush.start(streamKey, capabilities);
      
      expect(result).toBe(rtmpPush);
    });
  });

  describe("stop() method", () => {
    it("should stop running process", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      expect(rtmpPush.isRunning()).toBe(true);
      
      const result = rtmpPush.stop();
      
      expect(result).toBe(rtmpPush);
      expect(rtmpPush.isRunning()).toBe(false);
    });

    it("should handle stopping when no process is running", () => {
      expect(rtmpPush.isRunning()).toBe(false);
      
      const result = rtmpPush.stop();
      
      expect(result).toBe(rtmpPush);
      expect(rtmpPush.isRunning()).toBe(false);
    });

    it("should be chainable", () => {
      const result = rtmpPush.stop();
      expect(result).toBe(rtmpPush);
    });
  });

  describe("isRunning() method", () => {
    it("should return false when no process is started", () => {
      expect(rtmpPush.isRunning()).toBe(false);
    });

    it("should return true when process is running", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      expect(rtmpPush.isRunning()).toBe(true);
    });

    it("should return false after process is stopped", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      expect(rtmpPush.isRunning()).toBe(true);
      
      rtmpPush.stop();
      expect(rtmpPush.isRunning()).toBe(false);
    });
  });

  describe("Process lifecycle", () => {
    it("should handle process close event", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      
      // Simulate process close
      const closeHandler = mockProcess.on.mock.calls.find(call => call[0] === "close")?.[1];
      if (closeHandler && typeof closeHandler === 'function') {
        closeHandler(0);
      }
      
      expect(rtmpPush.isRunning()).toBe(false);
    });

    it("should handle process error event", () => {
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      
      // Simulate process error
      const errorHandler = mockProcess.on.mock.calls.find(call => call[0] === "error")?.[1];
      if (errorHandler && typeof errorHandler === 'function') {
        // Call the error handler with a mock error
        errorHandler(new Error("Process error"));
      }
      
      // The error handler should set the process to null
      expect(rtmpPush.isRunning()).toBe(false);
    });
  });

  describe("Edge cases", () => {
    it("should handle special characters in stream key", () => {
      const streamKey = "test-stream-with-special-chars!@#$%^&*()";
      const capabilities = ["h264"];
      
      rtmpPush.start(streamKey, capabilities);
      
      const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
      
      expect(mockSpawn).toHaveBeenCalledWith(
        "ffmpeg",
        expect.arrayContaining([expectedIngestUri])
      );
    });

    it("should handle special characters in capabilities", () => {
      const streamKey = "test-stream";
      const capabilities = ["h.264", "aac-lc", "stereo_audio"];
      
      rtmpPush.start(streamKey, capabilities);
      
      const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
      
      expect(mockSpawn).toHaveBeenCalledWith(
        "ffmpeg",
        expect.arrayContaining([expectedIngestUri])
      );
    });

    it("should handle very long URIs", () => {
      const longMediaUri = "https://example.com/" + "a".repeat(1000) + ".ts";
      const longRtmpUri = "rtmp://ingest.example.com:80/ingest/" + "b".repeat(1000);
      
      const longRtmpPush = new RtmpPush(longMediaUri, longRtmpUri);
      const streamKey = "test-stream";
      const capabilities = ["h264"];
      
      longRtmpPush.start(streamKey, capabilities);
      
      const expectedIngestUri = `${longRtmpUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
      
      expect(mockSpawn).toHaveBeenCalledWith(
        "ffmpeg",
        expect.arrayContaining([expectedIngestUri])
      );
    });
  });
});