import { createPrefixedLogger } from "~/lib/utils";
import {
    ClientMessageType,
    ConnectionState,
    ServerMessageType,
    type ClientMessage,
    type ServerMessage,
} from "./types";

export class WebRTCClient {
    private socket: WebSocket | null = null;
    private peerConnection: RTCPeerConnection | null = null;

    private onStateChange: (state: ConnectionState) => void;
    private onError: (error: Error) => void;
    private onRemoteStream: (stream: MediaStream) => void;

    private state: ConnectionState = ConnectionState.DISCONNECTED;
    private url: string;

    private connectionLock = false;
    private disconnectPromise: Promise<void> | null = null;
    private disconnectResolve: (() => void) | null = null;

    constructor(
        url: string,
        onStateChange: (state: ConnectionState) => void,
        onError: (error: Error) => void,
        onRemoteStream: (stream: MediaStream) => void,
    ) {
        this.url = url;
        this.onStateChange = onStateChange;
        this.onError = onError;
        this.onRemoteStream = onRemoteStream;
    }

    public connect = async (token: string) => {
        if (this.connectionLock) {
            warn("WebRTC: Connection already in progress");
            return;
        }

        this.connectionLock = true;

        if (
            this.state !== ConnectionState.DISCONNECTED &&
            this.state !== ConnectionState.ERROR
        ) {
            this.disconnect();
        }

        if (this.disconnectPromise) {
            warn("WebRTC: Waiting for previous disconnect to complete");
            try {
                await this.disconnectPromise;
            } catch (error) {
                console.error("WebRTC: Previous disconnect failed:", error);
            }
        }

        log("Connecting to %s", this.url);

        try {
            this.setState(ConnectionState.CONNECTING);

            this.socket = new WebSocket(this.url);

            this.socket.onopen = () => {
                log("Socket opened");

                this.connectionLock = false;

                this.setState(ConnectionState.AUTHENTICATING);
                this.sendMessage({
                    type: ClientMessageType.AUTHENTICATE,
                    data: { token },
                });
            };

            this.socket.onmessage = this.handleServerMessage;

            this.socket.onerror = (event) => {
                this.handleError(new Error("WebSocket error occurred"));
            };

            this.socket.onclose = (e) => {
                log("Socket closed", e);
                this.cleanupResources();
                if (this.state !== ConnectionState.ERROR) {
                    this.setState(ConnectionState.DISCONNECTED);
                }

                if (this.disconnectResolve) {
                    this.disconnectResolve();
                    this.disconnectResolve = null;
                    this.disconnectPromise = null;
                }
            };
        } catch (error) {
            this.handleError(
                error instanceof Error ? error : new Error("Unknown error"),
            );
        }
    };

    public disconnect = (): void => {
        if (this.state === ConnectionState.DISCONNECTED) {
            return;
        }

        this.setState(ConnectionState.DISCONNECTING);
        this.connectionLock = false;

        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
            // If we're already waiting for a disconnect, cancel it
            if (this.disconnectPromise) {
                this.disconnectResolve = null;
                this.disconnectPromise = null;
            }

            this.disconnectPromise = new Promise((resolve) => {
                this.disconnectResolve = resolve;
            });

            const onSocketClose = () => {
                this.socket?.removeEventListener("close", onSocketClose);
                this.disconnectResolve?.();
                this.disconnectResolve = null;
                this.disconnectPromise = null;
            };

            this.socket.addEventListener("close", onSocketClose);

            if (this.socket.readyState !== WebSocket.CLOSING) {
                this.socket.close(1000, "WebRTC: Cleaning up resources");
            }
        } else {
            this.cleanupResources();
            this.setState(ConnectionState.DISCONNECTED);
        }
    };

    public createOffer = async (localStream?: MediaStream): Promise<void> => {
        if (this.state !== ConnectionState.CONNECTED) {
            this.handleError(new Error("Cannot create offer: not connected"));
            return;
        }

        try {
            // Create RTCPeerConnection with standard configuration
            const configuration: RTCConfiguration = {
                iceServers: [],
            };

            this.peerConnection = new RTCPeerConnection(configuration);

            // Add local stream tracks if provided
            if (localStream) {
                localStream.getTracks().forEach((track) => {
                    this.peerConnection!.addTrack(track, localStream);
                });
            }

            // Handle ICE candidates
            this.peerConnection.onicecandidate = (event) => {
                if (event.candidate === null) {
                    // ICE gathering completed
                }
            };

            // Handle remote stream
            this.peerConnection.ontrack = (event) => {
                const [remoteStream] = event.streams;
                if (remoteStream) {
                    this.onRemoteStream(remoteStream);
                }
            };

            // Create offer and set local description
            const offer = await this.peerConnection.createOffer();
            await this.peerConnection.setLocalDescription(offer);

            // Send offer to server
            if (this.peerConnection.localDescription) {
                this.sendMessage({
                    type: ClientMessageType.SDP_OFFER,
                    data: {
                        sdp: this.peerConnection.localDescription,
                    },
                });
            }
        } catch (error) {
            this.handleError(
                error instanceof Error
                    ? error
                    : new Error("Error creating WebRTC offer"),
            );
        }
    };

    private handleServerMessage = async (
        event: MessageEvent,
    ): Promise<void> => {
        try {
            const message: ServerMessage = JSON.parse(event.data);

            log("Received message: %o", message);

            switch (message.type) {
                case ServerMessageType.AUTHENTICATE_ACCEPTED:
                    this.setState(ConnectionState.CONNECTED);
                    break;

                case ServerMessageType.AUTHENTICATE_DENIED:
                    this.handleError(new Error("Authentication failed"));
                    break;

                case ServerMessageType.SDP_ANSWER:
                    await this.handleSdpAnswer(message.data.sdp);
                    break;

                default:
                    warn("Unhandled message type:", message);
            }
        } catch (error) {
            this.handleError(
                error instanceof Error
                    ? error
                    : new Error("Failed to process message"),
            );
        }
    };

    private handleSdpAnswer = async (
        sdp: RTCSessionDescription,
    ): Promise<void> => {
        log("Received SDP answer: %o", sdp);

        if (!this.peerConnection) {
            this.handleError(new Error("No peer connection established"));
            return;
        }

        try {
            await this.peerConnection.setRemoteDescription(sdp);
        } catch (error) {
            this.handleError(
                error instanceof Error
                    ? error
                    : new Error("Error setting remote description"),
            );
        }
    };

    private sendMessage = (message: ClientMessage): void => {
        log("Sending message: %o", message);

        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
            this.socket.send(JSON.stringify(message));
        } else {
            this.handleError(
                new Error("Cannot send message: socket not connected"),
            );
        }
    };

    private setState = (state: ConnectionState): void => {
        log("State changed to %s", state);

        this.state = state;
        this.onStateChange(state);
    };

    private handleError = (error: Error): void => {
        log("Error: %s", error.message);

        this.setState(ConnectionState.ERROR);
        this.onError(error);
    };

    private cleanupResources = (): void => {
        log("Cleaning up resources");

        if (this.peerConnection) {
            this.peerConnection.close();
            this.peerConnection = null;
        }

        if (this.socket) {
            this.socket.close(1000, "WebRTC: Cleaning up resources");
            this.socket = null;
        }
    };
}

const { log, warn, ...other } = createPrefixedLogger("%cWebRTC WS%c:", [
    "color: blue; font-weight: bold;",
    "",
]);