/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   client.rs                                          :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: tomoron <tomoron@student.42angouleme.fr>   +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2026/05/07 17:23:09 by tomoron           #+#    #+#             */
/*   Updated: 2026/06/11 12:21:51 by tomoron          ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

use bollard::Docker;
use tokio::net::TcpStream;
use crate::minecraft::handshake::Handshake;
use std::fmt;

use crate::models::Servers;

use crate::DbPool;

use crate::schema;
use crate::models;
use diesel::prelude::*;

use regex::Regex;


pub struct Client {
    pub in_stream: TcpStream,

    pub read_buf: Vec<u8>,
    pub buffer: Vec<u8>,
    pub out_stream: Option<TcpStream>,
    pub handshake: Option<Handshake>,

    pub closed: bool,

    pub server: Option<Result<Servers,diesel::result::Error>>,

    pub db_pool: DbPool,
    pub docker: Docker
}

impl Client {
    pub fn create(stream: TcpStream, pool: DbPool, docker: Docker) -> Self {
        Self {
            in_stream: stream,

            read_buf: vec![0u8; 1024 * 8],
            buffer: vec![],
            out_stream: None,
            handshake: None,

            closed: false,

            server: None,

            db_pool: pool,

            docker: docker
        }
    }


    pub async fn get_server(&self) -> Result<Servers, diesel::result::Error> {
        println!("get server name from domain : {}", self.handshake.as_ref().unwrap().server_address);
        if let None = self.handshake {
            panic!("get server called without a handshake");
        }


        let conn = &mut self.db_pool.get().unwrap();

        let reg = Regex::new(r"^(?:([a-zA-Z-_]*)\.)?mc\.tmoron\.fr").unwrap();
        let mut found: Option<String> = None;
        if let Some(capture) = reg.captures(&self.handshake.as_ref().unwrap().server_address) {
            println!("capture : {:?}", capture);
            if let Some(captured_str) = capture.get(1) {
                println!("found valid capture : {}", captured_str.as_str());
                found = Some(captured_str.as_str().to_string());
            }
        }

        if let Some(name) = found {
            println!("found server name : {}", name);
            schema::servers::table.filter(schema::servers::name.eq(name)).select(models::Servers::as_select()).first(conn)
        } else {
            schema::servers::table.filter(schema::servers::is_default.eq(true)).select(models::Servers::as_select()).first(conn)

        }

    }

}

impl fmt::Display for Client {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(handshake) = &self.handshake {
            write!(f, "{}", handshake.server_address)
        } else {
            use std::os::unix::io::AsRawFd;
            write!(f, "{}", self.in_stream.as_raw_fd())
        }
    }
}