/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   main.rs                                            :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: tomoron <tomoron@student.42angouleme.fr>   +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2026/05/29 21:22:17 by tomoron           #+#    #+#             */
/*   Updated: 2026/05/29 21:31:39 by tomoron          ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

use tokio::net::TcpListener;
use tokio::io;
//use bollard::{
//    query_parameters::{
//        ListImagesOptionsBuilder,
//        ListContainersOptionsBuilder,
//        CreateContainerOptionsBuilder
//    },
//    models::{
//        ContainerCreateBody
//    },
//    Docker
//};

mod minecraft;
use minecraft::process_mc_socket;

mod rpc;
use rpc::process_rpc_socket;


use diesel::{prelude::*, r2d2::{ConnectionManager, Pool}};

//mod models;
 
//use dockermcmgr::schema;

//use crate::models::{ Servers, CreateServer };

use std::env;

//pub mod status;

//use status::ServerStatus;
//


pub type DbPool = Pool<ConnectionManager<PgConnection>>;

fn get_connection_pool() -> DbPool {
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let manager = ConnectionManager::<PgConnection>::new(&database_url);
    Pool::builder()
        .build(manager)
        .unwrap_or_else(|_| panic!("Error creating pool for {}", database_url))
}

#[tokio::main(flavor = "current_thread")]
async fn main() -> io::Result<()> {

    let pool = get_connection_pool();

    let mc_listener = TcpListener::bind("0.0.0.0:25565").await?;
    let rpc_listener = TcpListener::bind("0.0.0.0:8080").await?;

    loop {
        tokio::select! {
            Ok((socket, _)) = mc_listener.accept() => {
                let cloned = pool.clone();
                tokio::spawn(async move {
                    if let Err(e) = process_mc_socket(socket, cloned).await {
                        eprintln!("mc error: {:?}", e);
                    }
                });
            }

            Ok((socket, _)) = rpc_listener.accept() => {
                let cloned = pool.clone();
                tokio::spawn(async move {
                    if let Err(e) = process_rpc_socket(socket, cloned).await {
                        eprintln!("rpc error: {:?}", e);
                    }
                });
            }
        }
    }
    /*

    let conn = &mut pool.get().unwrap();


    let new_server = CreateServer {
        name: "potato",
        volume_path: "potato2",
        last_login: None,
        container_id: None,
        status: ServerStatus::Stopped,
        redirect_ip: None
    };

    match diesel::insert_into(schema::servers::table)
        .values(&new_server)
        .execute(conn) {
            Ok(a) => { println!("{:?}", a); },
            Err(reason) => {println!("got an error : {:?}", reason) }
        }

    let start = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let servers = schema::servers::table.select(Servers::as_select()).load(conn).unwrap();
    let end = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    println!("servers : {:?}", servers);
    println!("retreived in {:?}", end - start);


    println!("server id : {}",servers[0].id);

    Ok(())
        */
    /*
    println!("{:?}", docker);
    let options = ListImagesOptionsBuilder::default()
    .all(true)
    .build();
    let images = &docker.list_images(Some(options)).await.unwrap(); 
    println!("\n\nimages : {:?}", images);

    let options = ListContainersOptionsBuilder::default()
    .all(true)
    .build();

    let containers = docker.list_containers(Some(options)).await.unwrap();
    println!("\n\ncontainers : {:?}", containers);

    let options = CreateContainerOptionsBuilder::default()
    .name("rust-created-container")
    .build();

    let config = ContainerCreateBody {
        image: Some("hello-world".to_string()),
//        cmd: Some(vc pec!["/hello".to_string()]),
        ..Default::default()
    };

    let container = docker.create_container(Some(options), config).await.unwrap();

    let start_res = docker.start_container("rust-created-container", None).await;
*/
    /*
    */
}