use std::io::{BufRead, BufReader, Write};
use std::net::TcpListener;
use std::thread;

fn handle_client(stream: std::net::TcpStream) {
    println!("Client connected");
    let reader_stream = stream.try_clone().unwrap();
    let reader = BufReader::new(reader_stream);
    let mut writer = stream;
    for line in reader.lines() {
        let line = line.unwrap();
        println!("Received: {}", line);
        writeln!(writer, "{}", line).unwrap();
    }
    println!("Client disconnected");
}

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let mut ip = "127.0.0.1".to_string();
    let mut port = 8080;
    let mut i = 1;
    while i < args.len() {
        if args[i] == "-p" {
            if i + 1 < args.len() {
                port = args[i + 1].parse::<u16>().unwrap_or_else(|_| {
                    eprintln!("Invalid port number: {}", args[i + 1]);
                    std::process::exit(1);
                });
                i += 2;
            } else {
                eprintln!("-p requires a port number");
                std::process::exit(1);
            }
        } else if args[i] == "-i" {
            if i + 1 < args.len() {
                ip = args[i + 1].clone();
                if ip != "127.0.0.1" && ip != "0.0.0.0" {
                    eprintln!("Invalid IP address: {}. Must be 127.0.0.1 or 0.0.0.0", ip);
                    std::process::exit(1);
                }
                i += 2;
            } else {
                eprintln!("-i requires an IP address");
                std::process::exit(1);
            }
        } else {
            eprintln!("Unknown argument: {}", args[i]);
            std::process::exit(1);
        }
    }
    let listener = match TcpListener::bind(format!("{}:{}", ip, port)) {
        Ok(l) => l,
        Err(e) => {
            eprintln!("Failed to bind to {}:{}: {}", ip, port, e);
            std::process::exit(1);
        }
    };
    println!("Server listening on {}", listener.local_addr().unwrap());
    for stream in listener.incoming() {
        let stream = stream.unwrap();
        thread::spawn(move || {
            handle_client(stream);
        });
    }
}