use std::{convert::TryFrom, fmt::Display, io::Write};

use rand::Rng;

use crate::{
    error::{Error, ErrorKind},
    parser::item::Item,
};

#[derive(Debug, Clone, PartialEq)]
pub enum Abool {
    Never = -1,
    Sometimes = 0,
    Always = 1,
}

impl Display for Abool {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Abool::Never => write!(f, "never"),
            Abool::Sometimes => write!(f, "sometimes"),
            Abool::Always => write!(f, "always"),
        }
    }
}

impl From<Abool> for bool {
    fn from(val: Abool) -> Self {
        match val {
            Abool::Never => false,
            Abool::Always => true,
            Abool::Sometimes => rand::thread_rng().gen(), // NOTE(Able): This is amazing and should be applied anywhere abooleans exist
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum Functio {
    BfFunctio(Vec<u8>),
    AbleFunctio(Vec<Item>),
}

#[derive(Debug, Clone, PartialEq)]
pub enum Value {
    Nul,
    Str(String),
    Int(i32),
    Bool(bool),
    Abool(Abool),
    Functio(Functio),
}

impl Display for Value {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Value::Nul => write!(f, "nul"),
            Value::Str(v) => write!(f, "{}", v),
            Value::Int(v) => write!(f, "{}", v),
            Value::Bool(v) => write!(f, "{}", v),
            Value::Abool(v) => write!(f, "{}", v),
            Value::Functio(v) => match v {
                Functio::BfFunctio(source) => {
                    write!(
                        f,
                        "{}",
                        String::from_utf8(source.to_owned())
                            .expect("Brainfuck functio source should be UTF-8")
                    )
                }
                Functio::AbleFunctio(source) => {
                    // TODO: what's the proper way to display an
                    // AbleScript functio?
                    write!(f, "{:?}", source)
                }
            },
        }
    }
}

impl TryFrom<Value> for i32 {
    type Error = Error;

    fn try_from(value: Value) -> Result<Self, Self::Error> {
        match value {
            Value::Int(i) => Ok(i),
            _ => Err(Error {
                kind: ErrorKind::TypeError(format!("Expected int, got {}", value)),
                // TODO: either add some kind of metadata to `Value`
                // so we can tell where the value came from and assign
                // this `position` correctly, or re-write the
                // `error::Error` struct so we can omit the `position`
                // when using some error kinds.
                position: 0..0,
            }),
        }
    }
}

// Coercions from a value to a boolean always succeed, so every value
// can be used in an `if` statement. C does things that way, so how
// could it possibly be a bad idea?
impl From<Value> for bool {
    fn from(value: Value) -> Self {
        match value {
            // Booleans and abooleans have a trivial conversion.
            Value::Bool(b) => b,
            Value::Abool(b) => b.into(),
            // The empty string is falsey, other strings are truthy.
            Value::Str(s) => s.len() != 0,
            // 0 is falsey, nonzero is truthy.
            Value::Int(x) => x != 0,
            // Functios are always truthy.
            Value::Functio(_) => true,
            // And nul is truthy as a symbol of the fact that the
            // deep, fundamental truth of this world is nothing but
            // the eternal void.
            Value::Nul => true,
        }
    }
}

/// Allows writing AbleScript values to Brainfuck.
///
/// This trait is blanket implemented for all `Write`rs, but should
/// typically only be used for `Write`rs that cannot fail, e.g.,
/// `Vec<u8>`, because any IO errors will cause a panic.
///
/// The mapping from values to encodings is as follows, where all
/// multi-byte integers are little-endian:
///
/// | AbleScript representation | Brainfuck representation                                  |
/// |---------------------------|-----------------------------------------------------------|
/// | Nul                       | 00                                                        |
/// | Str                       | 01 [length, 4 bytes] [string, \[LENGTH\] bytes, as UTF-8] |
/// | Int                       | 02 [value, 4 bytes]                                       |
/// | Bool                      | 03 00 false, 03 01 true.                                  |
/// | Abool                     | 04 00 never, 04 01 always, 04 02 sometimes.               |
/// | Brainfuck Functio         | 05 00 [length, 4 bytes] [source code, \[LENGTH\] bytes]   |
/// | AbleScript Functio        | 05 01 (todo, not yet finalized or implemented)            |
///
/// The existing mappings should never change, as they are directly
/// visible from Brainfuck code and modifying them would break a
/// significant amount of AbleScript code. If more types are added in
/// the future, they should be assigned the remaining discriminant
/// bytes from 06..FF.
pub trait BfWriter {
    /// Write a value. Panic if writing fails for any reason.
    fn write_value(&mut self, value: &Value);
}

impl<T: Write> BfWriter for T {
    fn write_value(&mut self, value: &Value) {
        match value {
            Value::Nul => self.write_all(&[0]),
            Value::Str(s) => self
                .write_all(&[1])
                .and_then(|_| self.write_all(&(s.len() as u32).to_le_bytes()))
                .and_then(|_| self.write_all(&s.as_bytes())),
            Value::Int(v) => self
                .write_all(&[2])
                .and_then(|_| self.write_all(&v.to_le_bytes())),
            Value::Bool(b) => self
                .write_all(&[3])
                .and_then(|_| self.write_all(&[*b as _])),
            Value::Abool(a) => self.write_all(&[4]).and_then(|_| {
                self.write_all(&[match *a {
                    Abool::Never => 0,
                    Abool::Sometimes => 2,
                    Abool::Always => 1,
                }])
            }),
            Value::Functio(f) => self.write_all(&[5]).and_then(|_| match f {
                Functio::BfFunctio(f) => self
                    .write_all(&[0])
                    .and_then(|_| self.write_all(&(f.len() as u32).to_le_bytes()))
                    .and_then(|_| self.write_all(&f)),
                Functio::AbleFunctio(_) => {
                    todo!()
                }
            }),
        }
        .expect("Failed to write to Brainfuck input");
    }
}

#[derive(Debug)]
pub struct Variable {
    pub melo: bool,
    pub value: Value,
}