use std::fmt::{self};

use crate::command::IRCCommand;
use crate::error::{MessageError, MessageErrorDetails};

#[derive(Debug)]
pub struct Message {
    pub source: Option<String>,
    pub command: IRCCommand,
    pub params: Vec<String>,
}
impl fmt::Display for Message {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", String::from_utf8_lossy(self.serialize().as_ref()))
    }
}

static CR: u8 = 13;
static LF: u8 = 10;

impl Message {
    /// Returns the serialize of this [`Message`].
    ///
    /// Will truncate output to 510 characters and then include CR (13) and LF (10) suffix as per RFC 2812
    pub fn serialize(&self) -> Vec<u8> {
        let mut ret_val: Vec<u8> = vec![];
        if self.source.is_some() {
            ret_val = [
                ":".as_bytes().to_vec(),
                self.source.as_ref().unwrap().as_bytes().to_vec(),
                " ".as_bytes().to_vec(),
            ]
            .concat();
        }

        let mut params = self.params.join(" ");
        if self.needs_colon() {
            let mut modified_params = self.params.clone();
            modified_params[self.params.len() - 1] =
                format!(":{}", modified_params[modified_params.len() - 1]);
            params = modified_params.join(" ");
        }

        ret_val = [
            ret_val,
            self.command.command_text().as_bytes().to_vec(),
            " ".as_bytes().to_vec(),
            params.into(),
        ]
        .concat();

        ret_val.truncate(510);

        ret_val = [ret_val, vec![CR], vec![LF]].concat();

        ret_val
    }
    /// From a u8 vector representing an IRC message will return a [`Message`], will not validate presence of CRLF but will strip them before processing. An optional client prefix can be provided to override or represent the source of the IRC message.
    ///
    /// # Errors
    ///
    /// This function will return an error if the provided message is not a valid IRC message as per RFC 2812, including presence of no data, invalid commands and missing mandatory parameters.
    pub fn parse(
        mut raw_input: Vec<u8>,
        source_client: Option<String>,
    ) -> Result<Self, MessageError> {
        if raw_input.len() < 1 {
            return Err(MessageError {
                detail: MessageErrorDetails::NoData,
            });
        }
        if raw_input[raw_input.len() - 1] == LF {
            raw_input.pop();
        }
        if raw_input[raw_input.len() - 1] == CR {
            raw_input.pop();
        }

        let split_message: Vec<Vec<u8>> = raw_input.into_iter().fold(Vec::new(), |mut acc, x| {
            if x == 32 || acc.is_empty() {
                acc.push(Vec::new());
            }
            if x != 32 {
                acc.last_mut().unwrap().push(x);
            }
            acc
        });

        let mut source = source_client.clone();

        let mut command_index = 0;
        if split_message[0][0] == 58 {
            command_index = 1;
            let parsed_source = match Message::parse_prefix(split_message[0].clone()) {
                Ok(x) => x,
                Err(y) => return Err(y),
            };
            source = source_client.or_else(|| Some(parsed_source));
        }

        if split_message.len() < command_index + 1 {
            return Err(MessageError {
                detail: MessageErrorDetails::NoCommand,
            });
        }

        let irc_command = match Message::parse_command(split_message[command_index].clone()) {
            Ok(x) => x,
            Err(y) => return Err(y),
        };

        let params = match irc_command.parse_params(split_message[command_index + 1..].to_vec()) {
            Ok(x) => x,
            Err(y) => return Err(y),
        };

        Ok(Message {
            source: source,
            command: irc_command,
            params: params
                .iter()
                .map(|p| String::from_utf8_lossy(p).into_owned())
                .collect(),
        })
    }

    fn parse_command(command_input: Vec<u8>) -> Result<IRCCommand, MessageError> {
        let raw_command = match String::from_utf8(command_input) {
            Ok(x) => x,
            Err(_) => {
                return Err(MessageError {
                    detail: MessageErrorDetails::FailedCommandParse,
                })
            }
        };

        match raw_command.as_str() {
            "NAMES" => return Ok(IRCCommand::NAMES),
            "NICK" => return Ok(IRCCommand::NICK),
            "PRIVMSG" => return Ok(IRCCommand::PRIVMSG),
            "001" => return Ok(IRCCommand::RPL_WELCOME),
            "353" => return Ok(IRCCommand::RPL_NAMREPLY),
            "366" => return Ok(IRCCommand::RPL_ENDOFNAMES),
            "PING" => return Ok(IRCCommand::PING),
            "PONG" => return Ok(IRCCommand::PONG),
            "USER" => return Ok(IRCCommand::USER),
            "QUIT" => return Ok(IRCCommand::QUIT),
            "NOTICE" => return Ok(IRCCommand::NOTICE),
            "MOTD" => return Ok(IRCCommand::MOTD),
            "LUSERS" => return Ok(IRCCommand::LUSERS),
            "WHOIS" => return Ok(IRCCommand::WHOIS),
            "002" => return Ok(IRCCommand::RPL_YOURHOST),
            "003" => return Ok(IRCCommand::RPL_CREATED),
            "004" => return Ok(IRCCommand::RPL_MYINFO),
            "251" => return Ok(IRCCommand::RPL_LUSERCLIENT),
            "252" => return Ok(IRCCommand::RPL_LUSEROP),
            "253" => return Ok(IRCCommand::RPL_LUSERUNKNOWN),
            "254" => return Ok(IRCCommand::RPL_LUSERCHANNELS),
            "255" => return Ok(IRCCommand::RPL_LUSERME),
            "311" => return Ok(IRCCommand::RPL_WHOISUSER),
            "312" => return Ok(IRCCommand::RPL_WHOISSERVER),
            "318" => return Ok(IRCCommand::RPL_ENDOFWHOIS),
            "431" => return Ok(IRCCommand::ERR_NONICKNAMEGIVEN),
            "433" => return Ok(IRCCommand::ERR_NICKNAMEINUSE),
            "462" => return Ok(IRCCommand::ERR_ALREADYREGISTRED),
            "461" => return Ok(IRCCommand::ERR_NEEDMOREPARAMS),
            "451" => return Ok(IRCCommand::ERR_NOTREGISTERED),
            "421" => return Ok(IRCCommand::ERR_UNKNOWNCOMMAND),
            "411" => return Ok(IRCCommand::ERR_NORECIPIENT),
            "412" => return Ok(IRCCommand::ERR_NOTEXTTOSEND),
            "401" => return Ok(IRCCommand::ERR_NOSUCHNICK),
            "422" => return Ok(IRCCommand::ERR_NOMOTD),
            _ => {
                return Err(MessageError {
                    detail: MessageErrorDetails::InvalidCommand,
                })
            }
        }
    }

    fn parse_prefix(prefix_input: Vec<u8>) -> Result<String, MessageError> {
        if prefix_input.len() < 2 {
            return Err(MessageError {
                detail: MessageErrorDetails::NoClient,
            });
        }

        if prefix_input[0] == 58 {
            match String::from_utf8(prefix_input.clone().split_off(1)) {
                Ok(x) => return Ok(x),
                Err(_) => {
                    return Err(MessageError {
                        detail: MessageErrorDetails::FailedPrefixParse,
                    });
                }
            }
        } else {
            return Err(MessageError {
                detail: MessageErrorDetails::NoPrefix,
            });
        }
    }

    fn needs_colon(&self) -> bool {
        match self.command {
            IRCCommand::USER => true,
            _ => false,
        }
    }
}

#[test]
fn test_valid_command() {
    let message = "NAMES".as_bytes().to_vec();
    let command = Message::parse_command(message);
    assert_eq!(command, Ok(IRCCommand::NAMES));
}

#[test]
fn test_invalid_command() {
    let message = "NAMES2".as_bytes().to_vec();
    let command = Message::parse_command(message);
    assert!(command.is_err());
}

#[test]
fn test_blank_command() {
    let message = "".as_bytes().to_vec();
    let command = Message::parse_command(message);
    assert!(command.is_err());
}

#[test]
fn test_valid_source() {
    let message = ":TestClient".as_bytes().to_vec();
    let source = Message::parse_prefix(message);
    let source_string = match source {
        Ok(x) => x,
        Err(_) => "None".to_string(),
    };
    assert_eq!(source_string, "TestClient");
}
#[test]
fn test_invalid_source() {
    let message = ":".as_bytes().to_vec();
    let source = Message::parse_prefix(message);
    let source_string = match source {
        Ok(x) => x,
        Err(y) => y.detail.error_text().to_string(),
    };
    assert_eq!(source_string, "No client identifier");
}
#[test]
fn test_empty_source() {
    let message = Vec::new();
    let source = Message::parse_prefix(message);
    let source_string = match source {
        Ok(x) => x,
        Err(y) => y.detail.error_text().to_string(),
    };
    assert_eq!(source_string, "No client identifier");
}

#[test]
fn test_format_source() {
    let message = "TestClient".as_bytes().to_vec();
    let source = Message::parse_prefix(message);
    let source_string = match source {
        Ok(x) => x,
        Err(y) => y.detail.error_text().to_string(),
    };
    assert_eq!(source_string, "Missing : character");
}

#[test]
fn test_serialize() {
    let message = Message {
        source: Some("Anon".to_string()),
        command: IRCCommand::NICK,
        params: vec!["nonA".to_string()],
    };
    let output = message.serialize();
    println!("{:?}", output);
    assert_eq!(output.len(), 17);
    assert_eq!(output[output.len() - 3], 65);

    let message = Message {
        source: None,
        command: IRCCommand::NICK,
        params: vec!["nonA".to_string()],
    };
    let output = message.serialize();
    println!("{:?}", output);
    assert_eq!(output.len(), 11);
    assert_eq!(output[output.len() - 3], 65);
}

#[test]
fn test_user() {
    let message = Message {
        source: None,
        command: IRCCommand::USER,
        params: vec![
            "Anon".to_string(),
            "0".to_string(),
            "*".to_string(),
            "Anon".to_string(),
        ],
    };
    println!("{:?}", message);
    let output = message.serialize();
    println!("{:?}", output);
    assert_eq!(output.len(), 21);
    assert_eq!(output[14], 58);
}