use std::{

    fs::{File, OpenOptions},

    io::{Error, ErrorKind, Read, Result, Write},

    sync::{mpsc, Arc},

    task::Waker,

    thread,

};

use crate::{

    handlers::{IoResult, IoTask},

    server::database::Database,

};

use log::*;

pub type RequestId = u32;

pub struct IoThread {

    core_tx: mpsc::Sender<(RequestId, IoTask)>,

    core_rx: mpsc::Receiver<(RequestId, IoResult)>,

}

impl IoThread {

    pub fn new(waker: Waker) -> Self {

        let (core_tx, io_rx) = mpsc::channel();

        let (io_tx, core_rx) = mpsc::channel();

        todo!("convert into an IO task");

        /*let mut db = Database::new("localhost");

        thread::spawn(move || {

            while let Ok((request_id, task)) = io_rx.recv() {

                let response = match task {

                    IoTask::CheckRegistered { nick } => match db.is_registered(&nick) {

                        Ok(is_registered) => IoResult::AccountRegistered(is_registered),

                        Err(e) => {

                            warn!("Unable to check account's existence: {}", e);

                            IoResult::AccountRegistered(false)

                        }

                    },

                    IoTask::GetAccount {

                        nick,

                        protocol,

                        password_hash,

                        client_salt,

                        server_salt,

                    } => {

                        match db.get_account(

                            &nick,

                            protocol,

                            &password_hash,

                            &client_salt,

                            &server_salt,

                        ) {

                            Ok(account) => IoResult::Account(account),

                            Err(e) => {

                                warn!("Unable to get account data: {}", e);

                                IoResult::Account(None)

                            }

                        }

                    }

                    IoTask::GetCheckerAccount { nick, password } => {

                        match db.get_checker_account(&nick, &password) {

                            Ok(is_registered) => IoResult::CheckerAccount { is_registered },

                            Err(e) => {

                                warn!("Unable to get checker account data: {}", e);

                                IoResult::CheckerAccount {

                                    is_registered: false,

                                }

                            }

                        }

                    }

                    IoTask::GetReplay { id } => {

                        let result = match db.get_replay_name(id) {

                            Ok(Some(filename)) => {

                                let filename = format!(

                                    "checked/{}",

                                    if filename.starts_with("replays/") {

                                        &filename[8..]

                                    } else {

                                        &filename

                                    }

                                );

                                match crate::core::types::Replay::load(&filename) {

                                    Ok(replay) => Some(replay),

                                    Err(e) => {

                                        warn!(

                                            "Error while reading replay file \"{}\": {}",

                                            filename, e

                                        );

                                        None

                                    }

                                }

                            }

                            Ok(None) => None,

                            Err(e) => {

                                warn!("Unable to get replay name: {}", e);

                                None

                            }

                        };

                        IoResult::Replay(result)

                    }

                    IoTask::SaveRoom {

                        room_id,

                        filename,

                        contents,

                    } => {

                        let result = match save_file(&filename, &contents) {

                            Ok(()) => true,

                            Err(e) => {

                                warn!(

                                    "Error while writing the room config file \"{}\": {}",

                                    filename, e

                                );

                                false

                            }

                        };

                        IoResult::SaveRoom(room_id, result)

                    }

                    IoTask::LoadRoom { room_id, filename } => {

                        let result = match load_file(&filename) {

                            Ok(contents) => Some(contents),

                            Err(e) => {

                                warn!(

                                    "Error while writing the room config file \"{}\": {}",

                                    filename, e

                                );

                                None

                            }

                        };

                        IoResult::LoadRoom(room_id, result)

                    }

                };

                io_tx.send((request_id, response));

                waker.wake();

            }

        });*/

        Self { core_rx, core_tx }

    }

    pub fn send(&self, request_id: RequestId, task: IoTask) {

        self.core_tx.send((request_id, task)).unwrap();

    }

    pub fn try_recv(&self) -> Option<(RequestId, IoResult)> {

        match self.core_rx.try_recv() {

            Ok(result) => Some(result),

            Err(mpsc::TryRecvError::Empty) => None,

            Err(mpsc::TryRecvError::Disconnected) => unreachable!(),

        }

    }

}

fn save_file(filename: &str, contents: &str) -> Result<()> {

    let mut writer = OpenOptions::new().create(true).write(true).open(filename)?;

    writer.write_all(contents.as_bytes())

}

fn load_file(filename: &str) -> Result<String> {

    let mut reader = File::open(filename)?;

    let mut result = String::new();

    reader.read_to_string(&mut result)?;

    Ok(result)

}