use std::io;

pub mod reader;
pub mod writer;

pub use reader::TextReader;
pub use writer::TextWriter;

use crate::BinarySource;
use crate::BytesBinarySource;
use crate::Domain;
use crate::DomainDecode;
use crate::Shell;
use crate::ShellHandle;
use crate::ValueReader;

pub fn from_str<'de, D: Domain<'de>, Dec: DomainDecode<'de, D>>(
    s: &'de str,
    decode_embedded: &mut Dec,
) -> io::Result<ShellHandle<'de, D>> {
    Ok(Shell::read_domain(&mut BytesBinarySource::new(s.as_bytes()).text(), false, decode_embedded)?)
}

pub fn annotated_from_str<'de, D: Domain<'de>, Dec: DomainDecode<'de, D>>(
    s: &'de str,
    decode_embedded: &mut Dec,
) -> io::Result<ShellHandle<'de, D>> {
    Ok(Shell::read_domain(&mut BytesBinarySource::new(s.as_bytes()).text(), true, decode_embedded)?)
}

#[cfg(test)]
mod formatting_tests {
    use crate::{IOValue, Shell, ValueImpl};
    use crate::test_domain::Dom;

    #[test] fn format_debug_and_parse() {
        let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Shell<Dom>>().unwrap().wrap();
        assert_eq!(format!("{:?}", &v), "[1, {a: #!\"One\", z: 2}, 3]");
    }

    #[test] fn format_pretty_debug_and_parse() {
        let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Shell<Dom>>().unwrap().wrap();
        assert_eq!(format!("{:#?}", &v), concat!(
            "[\n",
            "    1,\n",
            "    {\n",
            "        a: #!\"One\",\n",
            "        z: 2\n",
            "    },\n",
            "    3\n",
            "]"));
    }

    #[test] fn iovalue_parse() {
        let v = "[1 @{a:b c:d} @\"foo\" #![2 3] 4]".parse::<IOValue>().unwrap();
        assert_eq!(format!("{:#?}", &v), concat!(
            "[\n",
            "    1,\n",
            "    @{\n",
            "        a: b,\n",
            "        c: d\n",
            "    } @\"foo\" #![\n",
            "        2,\n",
            "        3\n",
            "    ],\n",
            "    4\n",
            "]"));
    }
}

#[cfg(test)]
mod unusual_float_tests {
    use std::io;
    use crate::*;

    fn d32(u: u32, expected: &str) {
        let v = f32::from_bits(u);
        let w: IOValue = v.into();
        assert_eq!(format!("{:?}", w), expected);
        let x = expected.parse::<IOValue>().unwrap();
        assert_eq!(x, w);
    }

    fn d64(u: u64, expected: &str) {
        let v = f64::from_bits(u);
        let w: IOValue = v.into();
        assert_eq!(format!("{:?}", w), expected);
        let x = expected.parse::<IOValue>().unwrap();
        assert_eq!(x, w);
    }

    #[test] fn subnormal32() -> io::Result<()> {
        d32(0x00000100, "3.59e-43f");
        d32(0x80000100, "-3.59e-43f");
        Ok(())
    }

    #[test] fn normal32() -> io::Result<()> {
        d32(0x01000000, "2.3509887e-38f");
        d32(0x81000000, "-2.3509887e-38f");
        Ok(())
    }

    #[test] fn nan32() -> io::Result<()> {
        d32(0x7fc00000, "#xf\"7fc00000\"");
        d32(0x7fc5a5a5, "#xf\"7fc5a5a5\"");
        d32(0x7f800001, "#xf\"7f800001\"");
        d32(0x7f85a5a5, "#xf\"7f85a5a5\"");
        d32(0xffc00000, "#xf\"ffc00000\"");
        d32(0xffc5a5a5, "#xf\"ffc5a5a5\"");
        d32(0xff800001, "#xf\"ff800001\"");
        d32(0xff85a5a5, "#xf\"ff85a5a5\"");
        Ok(())
    }

    #[test] fn inf32() -> io::Result<()> {
        d32(0x7f800000, "#xf\"7f800000\"");
        d32(0xff800000, "#xf\"ff800000\"");
        Ok(())
    }

    #[test] fn subnormal64() -> io::Result<()> {
        d64(0x0000000000000100, "1.265e-321");
        d64(0x8000000000000100, "-1.265e-321");
        Ok(())
    }

    #[test] fn normal64() -> io::Result<()> {
        d64(0x0100000000000000, "7.291122019556398e-304");
        d64(0x8100000000000000, "-7.291122019556398e-304");
        Ok(())
    }

    #[test] fn nan64() -> io::Result<()> {
        d64(0x7ff8000000000000, "#xd\"7ff8000000000000\"");
        d64(0x7ff85a5a5a5a5a5a, "#xd\"7ff85a5a5a5a5a5a\"");
        d64(0x7ff0000000000001, "#xd\"7ff0000000000001\"");
        d64(0x7ff05a5a5a5a5a5a, "#xd\"7ff05a5a5a5a5a5a\"");
        d64(0xfff8000000000000, "#xd\"fff8000000000000\"");
        d64(0xfff85a5a5a5a5a5a, "#xd\"fff85a5a5a5a5a5a\"");
        d64(0xfff0000000000001, "#xd\"fff0000000000001\"");
        d64(0xfff05a5a5a5a5a5a, "#xd\"fff05a5a5a5a5a5a\"");
        Ok(())
    }

    #[test] fn inf64() -> io::Result<()> {
        d64(0x7ff0000000000000, "#xd\"7ff0000000000000\"");
        d64(0xfff0000000000000, "#xd\"fff0000000000000\"");
        Ok(())
    }
}