use anyhow::{Context, Result};
use std::{
    fmt::{Display, Formatter, Result as FmtResult},
    io::{BufRead, BufReader, Read},
};

/// OSSI Messaging Delimiters
const ACM_D: &str = "a";
const COMMAND_D: &str = "c";
const DATA_D: &str = "d";
const ERROR_D: &str = "e";
const FIELD_D: &str = "f";
const NEW_DATA_D: &str = "n";
const TERMINATOR_D: &str = "t";
const TAB: &str = "\t";

/// An OSSI protocol message. Used for input and output to and from the ACM. The
/// OSSI protocol is proprietary, and little documented. Here is a brief
/// overview. Every message consists of a single command and a
/// terminator used to separate messages. The message may also carry optional
/// tab-separated fields and datas when used for input. When used for output, it may
/// optionally carry an error. Example:
///
/// ```text
/// (input)
/// clist object
/// t
/// (output)
/// clist object
/// fhex_code\thex_code\thex_code
/// dentry\tentry\tentry
/// n
/// dentry\tentry\tentry
/// t
/// ```
#[derive(Debug, Default, Clone)]
pub struct Message {
    pub command: String,
    pub fields: Option<Vec<String>>,
    pub datas: Option<Vec<Vec<String>>>,
    pub error: Option<String>,
}

impl Message {
    /// Creates a new [Message] from its basic part: the command.
    pub fn new(command: &str) -> Self {
        Self {
            command: command.into(),
            ..Default::default()
        }
    }

    fn add_fields(&mut self, fields: Vec<String>) -> &mut Self {
        if !fields.is_empty() {
            if let Some(ref mut existing) = self.fields {
                existing.extend(fields.into_iter());
            } else {
                self.fields = Some(fields);
            }
        }

        self
    }

    fn add_data_entry(&mut self, data: Vec<String>) -> &mut Self {
        if !data.is_empty() {
            if let Some(ref mut existing) = self.datas {
                existing.push(data);
            } else {
                self.datas = Some(vec![data]);
            }
        }

        self
    }

    /// Reads from `readable`, parsing lines as Angelshark-formatted OSSI input.
    /// This closely follows the OSSI spec, but also parses ACM names/labels on
    /// lines beginning with `'a'`. The spec looks like this:
    ///
    /// ```text
    /// aACM01
    /// clist object
    /// fhex_code\thex_code\thex_code
    /// dentry\tentry\tentry
    /// t
    /// ...
    /// ```
    pub fn from_input(readable: impl Read) -> Result<Vec<(String, Self)>> {
        let mut data = Vec::new();
        let mut input = Self::default();
        let mut inputs = Vec::new();
        let mut names: Vec<String> = Vec::new();

        for line in BufReader::new(readable).lines() {
            let line = line.with_context(|| "Failed to read line of input.")?;
            let (delim, content) = (line.get(0..1).unwrap_or_default(), line.get(1..));

            match (delim, content) {
                (ACM_D, Some(a)) => {
                    names.extend(a.split(TAB).map(String::from));
                }
                (COMMAND_D, Some(c)) => {
                    input.command = c.into();
                }
                (FIELD_D, Some(f)) => {
                    input.add_fields(f.split(TAB).map(String::from).collect());
                }
                (DATA_D, Some(d)) => {
                    data.extend(d.split(TAB).map(String::from));
                }
                (TERMINATOR_D, _) => {
                    input.add_data_entry(data);
                    inputs.extend(names.into_iter().map(|n| (n, input.clone())));
                    names = Vec::new();
                    input = Message::default();
                    data = Vec::new();
                }
                _ => {
                    // Skip blank lines and unknown identifiers.
                }
            }
        }

        Ok(inputs)
    }

    /// Reads `readable` and parses lines as ACM OSSI output. This should exactly follow the OSSI spec.
    pub fn from_output(readable: impl Read) -> Result<Vec<Self>> {
        let mut data = Vec::new();
        let mut output = Self::default();
        let mut outputs = Vec::new();

        for line in BufReader::new(readable).lines() {
            let line = line.with_context(|| "Failed to read line of output.")?;
            let (delim, content) = (line.get(0..1).unwrap_or_default(), line.get(1..));

            match (delim, content) {
                (COMMAND_D, Some(c)) => {
                    output.command = c.into();
                }
                (ERROR_D, Some(e)) => {
                    output.error = Some(e.into());
                }
                (FIELD_D, Some(f)) => {
                    output.add_fields(f.split(TAB).map(String::from).collect());
                }
                (DATA_D, Some(d)) => {
                    data.extend(d.split(TAB).map(String::from));
                }
                (NEW_DATA_D, _) => {
                    output.add_data_entry(data);
                    data = Vec::new();
                }
                (TERMINATOR_D, _) => {
                    output.add_data_entry(data);
                    data = Vec::new();
                    outputs.push(output);
                    output = Self::default();
                }
                _ => {
                    // Ignore unknown identifiers and blank lines.
                }
            }
        }

        Ok(outputs)
    }
}

impl Display for Message {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        let mut message = format!("c{}\n", self.command);

        if let Some(error) = &self.error {
            message = message + &format!("e{}\n", error);
        }

        if let Some(fields) = &self.fields {
            message = message + &format!("f{}\n", fields.join(TAB));
        }

        if let Some(datas) = &self.datas {
            message = message
                + &datas
                    .iter()
                    .map(|d| format!("d{}\n", d.join(TAB)))
                    .collect::<Vec<String>>()
                    .join("n\n");
        }

        writeln!(f, "{}\nt", message)
    }
}