use std::fmt;

use std::fs::File;

use std::io;

use std::path::Path;

use backtrace::Backtrace;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct InputSource {

    filename: String,

    input: Vec<u8>,

    line: usize,

    column: usize,

    offset: usize,

}

static STD_LIB_PDL: &'static [u8] = b"

primitive forward(in i, out o) {

    while(true) synchronous() put(o, get(i));

}

primitive sync(in i, out o) {

    while(true) synchronous() if(fires(i)) put(o, get(i));

}

    while(true) {

        synchronous() if(fires(i)) put(l, get(i));

        synchronous() if(fires(i)) put(r, get(i));

    }

}

    while(true) synchronous() if(fires(i)) {

        msg m = get(i);

        put(l, m);

        put(r, m);

    }

}

    while(true) synchronous {

        if(fires(l))      put(o, get(l));

        else if(fires(r)) put(o, get(r));

    }

}";

impl InputSource {

    // Constructors

    pub fn new<R: io::Read, S: ToString>(filename: S, reader: &mut R) -> io::Result<InputSource> {

        let mut vec = STD_LIB_PDL.to_vec();

        reader.read_to_end(&mut vec)?;

        Ok(InputSource {

            filename: filename.to_string(),

            input: vec,

            line: 1,

            column: 1,

            offset: 0,

        })

    }

    // Constructor helpers

    pub fn from_file(path: &Path) -> io::Result<InputSource> {

        let filename = path.file_name();

        match filename {

            Some(filename) => {

                let mut f = File::open(path)?;

                InputSource::new(filename.to_string_lossy(), &mut f)

            }

            None => Err(io::Error::new(io::ErrorKind::NotFound, "Invalid path")),

        }

    }

    pub fn from_string(string: &str) -> io::Result<InputSource> {

        let buffer = Box::new(string);

        let mut bytes = buffer.as_bytes();

        InputSource::new(String::new(), &mut bytes)

    }

    pub fn from_buffer(buffer: &[u8]) -> io::Result<InputSource> {

        InputSource::new(String::new(), &mut Box::new(buffer))

    }

    // Internal methods

    pub fn pos(&self) -> InputPosition {

        InputPosition { line: self.line, column: self.column, offset: self.offset }

    }

    pub fn error<S: ToString>(&self, message: S) -> ParseError {

        self.pos().parse_error(message)

    }

    pub fn is_eof(&self) -> bool {

        self.next() == None

    }

    pub fn next(&self) -> Option<u8> {

        if self.offset < self.input.len() {

            Some((*self.input)[self.offset])

        } else {

            None

        }

    }

    pub fn lookahead(&self, pos: usize) -> Option<u8> {

        if let Some(x) = usize::checked_add(self.offset, pos) {

            if x < self.input.len() {

                return Some((*self.input)[x]);

            }

        }

        None

    }

    pub fn consume(&mut self) {

        match self.next() {

            Some(x) if x == b'\r' && self.lookahead(1) != Some(b'\n') || x == b'\n' => {

                self.line += 1;

                self.offset += 1;

                self.column = 1;

            }

            Some(_) => {

                self.offset += 1;

                self.column += 1;

            }

            None => {}

        }

    }

}

impl fmt::Display for InputSource {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        self.pos().fmt(f)

    }

}

#[derive(Debug, Clone, Copy, Default, serde::Serialize, serde::Deserialize)]

pub struct InputPosition {

    line: usize,

    column: usize,

    offset: usize,

}

impl InputPosition {

    fn context<'a>(&self, source: &'a InputSource) -> &'a [u8] {

        let start = self.offset - (self.column - 1);

        let mut end = self.offset;

        while end < source.input.len() {

            let cur = (*source.input)[end];

            if cur == b'\n' || cur == b'\r' {

                break;

            }

            end += 1;

        }

        &source.input[start..end]

    }

    fn parse_error<S: ToString>(&self, message: S) -> ParseError {

        ParseError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }

    }

    fn eval_error<S: ToString>(&self, message: S) -> EvalError {

        EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }

    }

}

impl fmt::Display for InputPosition {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "{}:{}", self.line, self.column)

    }

}

pub trait SyntaxElement {

    fn position(&self) -> InputPosition;

    fn error<S: ToString>(&self, message: S) -> EvalError {

        self.position().eval_error(message)

    }

}

#[derive(Debug, Clone)]

pub struct ParseError {

    position: InputPosition,

    message: String,

    backtrace: Backtrace,

}

impl ParseError {

    pub fn new<S: ToString>(position: InputPosition, message: S) -> ParseError {

        ParseError { position, message: message.to_string(), backtrace: Backtrace::new() }

    }

    // Diagnostic methods

    pub fn write<A: io::Write>(&self, source: &InputSource, writer: &mut A) -> io::Result<()> {

        if !source.filename.is_empty() {

            writeln!(

                writer,

                "Parse error at {}:{}: {}",

                source.filename, self.position, self.message

            )?;

        } else {

            writeln!(writer, "Parse error at {}: {}", self.position, self.message)?;

        }

        let line = self.position.context(source);

        writeln!(writer, "{}", String::from_utf8_lossy(line))?;

        let mut arrow: Vec<u8> = Vec::new();

        for pos in 1..self.position.column {

            let c = line[pos - 1];

            if c == b'\t' {

                arrow.push(b'\t')

            } else {

                arrow.push(b' ')

            }

        }

        arrow.push(b'^');

        writeln!(writer, "{}", String::from_utf8_lossy(&arrow))

    }

    pub fn print(&self, source: &InputSource) {

        self.write(source, &mut std::io::stdout()).unwrap()

    }

    pub fn display<'a>(&'a self, source: &'a InputSource) -> DisplayParseError<'a> {

        DisplayParseError::new(self, source)

    }

}

impl From<ParseError> for io::Error {

    fn from(_: ParseError) -> io::Error {

        io::Error::new(io::ErrorKind::InvalidInput, "parse error")

    }

}

#[derive(Clone, Copy)]

pub struct DisplayParseError<'a> {

    error: &'a ParseError,

    source: &'a InputSource,

}

impl DisplayParseError<'_> {

    fn new<'a>(error: &'a ParseError, source: &'a InputSource) -> DisplayParseError<'a> {

        DisplayParseError { error, source }

    }

}

impl fmt::Display for DisplayParseError<'_> {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        let mut vec: Vec<u8> = Vec::new();

        match self.error.write(self.source, &mut vec) {

    let barrier = std::sync::Barrier::new(2);

    scope(|s| {

        s.spawn(|_| {

            barrier.wait();

            // reowolf thread

            let mut c = file_logged_connector(0, test_log_path);

            let [p0, p1] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();

            c.connect(SEC1).unwrap();

            c.put(p0, TEST_MSG.clone()).unwrap();

            c.get(p1).unwrap();

            c.sync(SEC5).unwrap();

            assert_eq!(c.gotten(p1).unwrap().as_slice(), TEST_MSG_BYTES);

            barrier.wait();

        });

        s.spawn(|_| {

            barrier.wait();

            // udp thread

            let udp = std::net::UdpSocket::bind(sock_addrs[1]).unwrap();

            udp.connect(sock_addrs[0]).unwrap();

            let mut buf = new_u8_buffer(256);

            for _ in 0..5 {

                std::thread::sleep(Duration::from_millis(60));

                udp.send(TEST_MSG_BYTES).unwrap();

            }

            let len = udp.recv(&mut buf).unwrap();

            assert_eq!(TEST_MSG_BYTES, &buf[0..len]);

            barrier.wait();

        });

    })

    .unwrap();

}

#[test]

fn example_pres_3() {

    let test_log_path = Path::new("./logs/example_pres_3");

    let sock_addrs = [next_test_addr(), next_test_addr()];

    scope(|s| {

        s.spawn(|_| {

            // "amy"

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();

            c.connect(SEC1).unwrap();

            // put {A} and FAIL

            c.put(p0, TEST_MSG.clone()).unwrap();

            c.sync(SEC1).unwrap_err();

            // put {B} and FAIL

            c.put(p1, TEST_MSG.clone()).unwrap();

            c.sync(SEC1).unwrap_err();

            // put {A, B} and SUCCEED

            c.put(p0, TEST_MSG.clone()).unwrap();

            c.put(p1, TEST_MSG.clone()).unwrap();

            c.sync(SEC1).unwrap();

        });

        s.spawn(|_| {

            // "bob"

            let mut c = file_logged_connector(1, test_log_path);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..2 {

                // get {A, B} and FAIL

                c.get(p0).unwrap();

                c.get(p1).unwrap();

                c.sync(SEC1).unwrap_err();

            }

            // get {A, B} and SUCCEED

            c.get(p0).unwrap();

            c.get(p1).unwrap();

            c.sync(SEC1).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn ac_not_b() {

    let test_log_path = Path::new("./logs/ac_not_b");

    let sock_addrs = [next_test_addr(), next_test_addr()];

    scope(|s| {

        s.spawn(|_| {

            // "amy"

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();

            c.connect(SEC1).unwrap();

            // put both A and B

            c.put(p0, TEST_MSG.clone()).unwrap();

            c.put(p1, TEST_MSG.clone()).unwrap();

            c.sync(SEC1).unwrap_err();

        });

        s.spawn(|_| {

            // "bob"

            let pdl = b"

            primitive ac_not_b(in a, in b, out c){

                // forward A to C but keep B silent

                synchronous{ put(c, get(a)); }

            }";

            let pd = Arc::new(reowolf::ProtocolDescription::parse(pdl).unwrap());

            let mut c = file_logged_configured_connector(1, test_log_path, pd);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            let [a, b] = c.new_port_pair();

            c.add_component(b"ac_not_b", &[p0, p1, a]).unwrap();

            c.connect(SEC1).unwrap();

            c.get(b).unwrap();

            c.sync(SEC1).unwrap_err();

        });

    })

    .unwrap();

}

#[test]

fn many_rounds_net() {

    let test_log_path = Path::new("./logs/many_rounds_net");

    let sock_addrs = [next_test_addr()];

    const NUM_ROUNDS: usize = 1_000;

    scope(|s| {

        s.spawn(|_| {

            let mut c = file_logged_connector(0, test_log_path);

            let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..NUM_ROUNDS {

                c.put(p0, TEST_MSG.clone()).unwrap();

                c.sync(SEC1).unwrap();

            }

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            c.connect(SEC1).unwrap();

            for _ in 0..NUM_ROUNDS {

                c.get(p0).unwrap();

                c.sync(SEC1).unwrap();

            }

        });

    })

    .unwrap();

}

#[test]

fn many_rounds_mem() {

    let test_log_path = Path::new("./logs/many_rounds_mem");

    const NUM_ROUNDS: usize = 1_000;

    let mut c = file_logged_connector(0, test_log_path);

    let [p0, p1] = c.new_port_pair();

    c.connect(SEC1).unwrap();

    for _ in 0..NUM_ROUNDS {

        c.put(p0, TEST_MSG.clone()).unwrap();

        c.get(p1).unwrap();

        c.sync(SEC1).unwrap();

    }

}

#[test]

fn pdl_reo_lossy() {

    let pdl = b"

    primitive lossy(in a, out b) {

        while(true) synchronous {

            msg m = null;

            if(fires(a)) {

                m = get(a);

                if(fires(b)) {

                    put(b, m);

                }

            }

        }

    }

    ";

    reowolf::ProtocolDescription::parse(pdl).unwrap();

}

#[test]

fn pdl_reo_fifo1() {

    let pdl = b"

    primitive fifo1(in a, out b) {

        msg m = null;

        while(true) synchronous {

            if(m == null) {

                if(fires(a)) m=get(a);

            } else {

                if(fires(b)) put(b, m);

                m = null;

            }

        }

    }

    ";

    reowolf::ProtocolDescription::parse(pdl).unwrap();

}

#[test]

    let pdl = b"

        msg m = create(0);

        while(true) synchronous {

            if(m == null) {

                if(fires(a)) m=get(a);

            } else {

                if(fires(b)) put(b, m);

                m = null;

            }

        }

    }

    ";

    let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();

    let mut c = Connector::new(Box::new(DummyLogger), Arc::new(pd), 0);

    let [_p0, g0] = c.new_port_pair();

    let [p1, g1] = c.new_port_pair();

    c.connect(None).unwrap();

    c.get(g1).unwrap();

    c.sync(None).unwrap();

    assert_eq!(0, c.gotten(g1).unwrap().len());

}