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;

                // 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());

}