use crate::fixture_bytes;
use bstr::ByteVec;
use git_transport::client::Transport;
use git_transport::{client::http, Protocol};
use std::{
    io::{Read, Write},
    net::SocketAddr,
    time::Duration,
};

enum Command {
    ReadAndRespond(Vec<u8>),
}

enum CommandResult {
    ReadAndRespond(Vec<u8>),
}

pub struct Server {
    pub addr: SocketAddr,
    send_command: std::sync::mpsc::SyncSender<Command>,
    recv_result: std::sync::mpsc::Receiver<CommandResult>,
}

impl Server {
    pub fn new(fixture: Vec<u8>) -> Self {
        let ports = (15411..).take(10);
        let listener = std::net::TcpListener::bind(
            ports
                .map(|port| SocketAddr::from(([127, 0, 0, 1], port)))
                .collect::<Vec<_>>()
                .as_slice(),
        )
        .expect("one of these ports to be free");
        let addr = listener.local_addr().expect("a local address");
        let (send_result, recv_result) = std::sync::mpsc::sync_channel(0);
        let (send_command, recv_commands) = std::sync::mpsc::sync_channel(0);
        std::thread::spawn(move || {
            for command in recv_commands {
                match command {
                    Command::ReadAndRespond(response) => {
                        let (mut stream, _) = listener.accept().expect("accept to always work");
                        stream
                            .set_read_timeout(Some(Duration::from_millis(50)))
                            .expect("timeout to always work");
                        stream
                            .set_write_timeout(Some(Duration::from_millis(50)))
                            .expect("timeout to always work");
                        let mut out = Vec::new();
                        stream.read_to_end(&mut out).ok();
                        stream.write_all(&response).expect("write to always work");
                        stream.flush().expect("flush to work");
                        if send_result.send(CommandResult::ReadAndRespond(out)).is_err() {
                            break;
                        }
                    }
                }
            }
        });
        send_command
            .send(Command::ReadAndRespond(fixture))
            .expect("send to go through when thread is up");
        Server {
            addr,
            send_command,
            recv_result,
        }
    }

    pub fn next_read_and_respond_with(&self, fixture: Vec<u8>) {
        self.send_command
            .send(Command::ReadAndRespond(fixture))
            .expect("thread to be waiting");
    }

    pub fn ignore_this_result(&self) {
        self.recv_result.recv().ok();
    }

    pub fn received(&self) -> Vec<u8> {
        match self.recv_result.recv().expect("thread to be up") {
            CommandResult::ReadAndRespond(received) => received,
        }
    }

    pub fn addr(&self) -> &SocketAddr {
        &self.addr
    }

    pub fn received_as_string(&self) -> String {
        self.received().into_string().expect("utf8 only")
    }
}

pub fn serve_once(name: &str) -> Server {
    Server::new(fixture_bytes(name))
}

pub fn serve_and_connect(
    name: &str,
    path: &str,
    version: Protocol,
) -> Result<(Server, http::Transport<http::Impl>), crate::Error> {
    let server = serve_once(name);
    let url = format!(
        "http://{}:{}/{}",
        &server.addr().ip().to_string(),
        &server.addr().port(),
        path
    );
    let client = git_transport::client::http::connect(&url, version)?;
    assert_eq!(url, client.to_url());
    Ok((server, client))
}