use std::thread::{spawn, sleep};
use std::net::{TcpListener, TcpStream, Shutdown, ToSocketAddrs, IpAddr, Ipv4Addr};
use std::time::Duration;
use std::sync::{Mutex, Arc};
use std::io::ErrorKind;
use std::io::{Read, Write, Error};
use std::io;

enum WriteType {
    Encode,
    Decode
}

fn resolve(host: &str) -> io::Result<Ipv4Addr> {
    let addrs: Vec<IpAddr> = (host, 0).to_socket_addrs().map(|iter| iter.map(|socket_address| socket_address.ip()).collect())?;
    for addr in addrs.into_iter() {
        match addr {
            IpAddr::V4(t) => { return Ok(t); },
            IpAddr::V6(_t) => {  },
        };
    };
    Err(Error::new(ErrorKind::NotFound, "Adress not found"))
}

fn main() {
    let listener = TcpListener::bind("127.0.0.1:2027").unwrap();

    for stream in listener.incoming() {
        let stream = stream.unwrap();
        stream.set_nonblocking(true).unwrap();

        spawn(|| {
            handle_stream(stream);
        });
    }
}

fn handle_stream(browser: TcpStream) {
    let addr = "78.82.230.209:80".parse().unwrap();
    let timeout = Duration::from_secs(15);
    let server: TcpStream;
    match TcpStream::connect_timeout(&addr, timeout) {
        Ok(s) => { server = s; },
        Err(e) => { panic!(e) }
    }

    server.set_nonblocking(true).unwrap();

    let server_mutex = Arc::new(Mutex::new(server));
    let browser_mutex = Arc::new(Mutex::new(browser));

    let server_clone = Arc::clone(&server_mutex);
    let browser_clone = Arc::clone(&browser_mutex);

    let server_clone2 = Arc::clone(&server_mutex);
    let browser_clone2 = Arc::clone(&browser_mutex);

    copy(server_clone, browser_clone, WriteType::Decode);
    copy(browser_clone2, server_clone2, WriteType::Encode);
}

fn encode(data: &[u8]) -> Vec<u8> {
//    println!("<-{:?}", data);
    let retval: Vec<u8>;
    let mut data_vec = data.to_vec();
    if data.len() > 4 && data[..4] == [5, 1, 0, 3] {
        let mut new_data: Vec<u8> = [5, 1, 0, 1].to_vec();
        let len = data[4] as usize;
        let host = String::from_utf8_lossy(&data[5..5+len]);
//        println!("Host: {:?}", host);
        let ip = resolve(&host.to_string()).unwrap().octets();
        let port = &data[5+len..];
//        println!("Ip: {:?}", ip);
        new_data.extend_from_slice(&ip);
        new_data.extend_from_slice(port);
        data_vec = new_data;
    }
    retval = data_vec.into_iter().map(|byte| {
        if byte < 12u8 { byte + 244u8 } else { byte - 12u8 }
    }).collect();
    retval
}

fn decode(data: &mut [u8]) -> Vec<u8> {
    let mut retval: Vec<u8> = vec![];
    for t in data {
        let byte = *t;
        let d = if byte > 243u8 { byte - 244u8 } else { byte + 12u8 };
        retval.push(d);
    }
//    println!("->{:?}", retval);
    retval
}

fn copy(from: Arc<Mutex<TcpStream>>,
        to: Arc<Mutex<TcpStream>>,
        write_type: WriteType) {

    spawn(move || {
        let mut buf = [0u8;4096];
        let mut empty_response = 0;
        loop {
            let mut count = 0;
            {
                let mut from_guard = from.lock().unwrap();
                match from_guard.read(&mut buf) {
                    Ok(c) => { count = c },
                    Err(ref e) if e.kind() == ErrorKind::WouldBlock => { },
                    Err(_) => { break }
                };
            }
            if count > 0 {
                empty_response = 0;
                let result = match write_type {
                    WriteType::Encode => encode(&mut buf[0..count]),
                    WriteType::Decode => decode(&mut buf[0..count])
                };
                let mut to_guard = to.lock().unwrap();
                match to_guard.write(&result) {
                    Ok(_) => to_guard.flush().unwrap(),
                    Err(_) => { break }
                };
            } else {
                empty_response += 1;
                if empty_response == 5000 { break };
                sleep(Duration::from_millis(1));
            }
        }
        let from_guard = from.lock().unwrap();
        let to_guard = to.lock().unwrap();
        from_guard.shutdown(Shutdown::Both).unwrap_or_else(|_|{});
        to_guard.shutdown(Shutdown::Both).unwrap_or_else(|_|{});
    });
}