use std::{fmt::Display, str::FromStr};

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserAndSignal {
    pub user: User,
    pub signal: Signal,
}
impl UserAndSignal {
    pub async fn new(user: User, signal: Signal) -> Self {
        UserAndSignal { user, signal }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct User {
    pub username: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Error {
    InvalidSignalType(String),
    UnexpectedSignalType(SignalType),
    WebSocketInitialization,
    WebSocketAuth,
    WebSocketSend(String),
    WebSocketReceivedNothing,
    WebSocketReceiveQueueReset,
    WebSocketReceiveQueueLocked,
    WebRTCInitialization,
    WebRTCOffer,
    WebRTCAnswer,
    WebRTCSessionDescriptionProtocol,
    WebRTCSetLocalDescription,
    WebRTCSetRemoteDescription,
    OfferChannelReceive(String),
    AnswerChannelReceive(String),
    ICECandidateChannelReceive(String),
    ICECandidateAdd,
}

impl std::error::Error for Error {
    fn cause(&self) -> Option<&dyn std::error::Error> {
        self.source()
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::InvalidSignalType(invalid_signal_type) => {
                write!(f, "Invalid Signal Type: {}", invalid_signal_type)
            }

            Error::UnexpectedSignalType(signal_type) => {
                write!(f, "Unexpected Signal Type: {}", signal_type)
            }

            Error::WebSocketInitialization => write!(f, "WebSocket Initialization"),
            Error::WebSocketAuth => write!(f, "WebSocket Auth"),
            Error::WebSocketSend(send_error) => write!(f, "WebSocket Send: {}", send_error),
            Error::WebSocketReceivedNothing => write!(f, "WebSocket Received Nothing"),
            Error::WebSocketReceiveQueueReset => write!(f, "WebSocket Receive Queue Reset"),
            Error::WebSocketReceiveQueueLocked => write!(f, "WebSocket Receive Queue Locked"),
            Error::WebRTCInitialization => write!(f, "WebRTC Initialization"),
            Error::WebRTCOffer => write!(f, "WebRTC Offer"),
            Error::WebRTCAnswer => write!(f, "WebRTC Answer"),
            Error::WebRTCSessionDescriptionProtocol => {
                write!(f, "WebRTC Session Description Protocol")
            }
            Error::WebRTCSetLocalDescription => write!(f, "WebRTC Set Local Description"),
            Error::WebRTCSetRemoteDescription => write!(f, "WebRTC Set Remote Description"),
            Error::OfferChannelReceive(recv_error) => {
                write!(f, "Offer Channel Receive | {}", recv_error)
            }
            Error::AnswerChannelReceive(recv_error) => {
                write!(f, "Answer Channel Receive | {}", recv_error)
            }
            Error::ICECandidateChannelReceive(recv_error) => {
                write!(f, "ICE Candidate Channel Receive | {}", recv_error)
            }
            Error::ICECandidateAdd => write!(f, "ICE Candidate Add"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SignalType {
    Auth,
    Offer,
    Answer,
    ICECandidate,
}

impl FromStr for SignalType {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "Auth" => Ok(SignalType::Auth),
            "Offer" => Ok(SignalType::Offer),
            "Answer" => Ok(SignalType::Answer),
            _ => Err(Error::InvalidSignalType(s.to_owned())),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Signal {
    signal_type: SignalType,
    data: String,
    time: DateTime<Utc>,
}

impl Display for SignalType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SignalType::Auth => write!(f, "Auth"),
            SignalType::Offer => write!(f, "Offer"),
            SignalType::Answer => write!(f, "Answer"),
            SignalType::ICECandidate => write!(f, "ICE Candidate"),
        }
    }
}

impl Signal {
    pub fn new(signal_type: &SignalType, data: &String) -> Signal {
        let signal_type = *signal_type;
        let data = data.to_owned();
        Signal {
            signal_type,
            data,
            time: DateTime::default(),
        }
    }

    pub fn get_signal_type(&self) -> SignalType {
        self.signal_type
    }
    pub fn get_data(&self) -> String {
        self.data.to_owned()
    }
    pub fn get_time(&self) -> DateTime<Utc> {
        self.time
    }
}