use async_std::net::{SocketAddr, TcpStream};
use async_std::sync::{Arc, Mutex, RwLock};
use chrono::{NaiveDateTime, Utc};
use futures::io::BufReader;
use futures::io::{AsyncBufReadExt, AsyncWriteExt};
use futures::io::{ReadHalf, WriteHalf};
use log::{debug, info};
use serde::Serialize;
use serde_json::{Map, Value};
use std::net::IpAddr;
use std::time::SystemTime;
use stratum_types::Result;
use stratum_types::{Error, ID};
use uuid::Uuid;

#[derive(PartialEq, Debug)]
pub enum ConnectionState {
    Connected,
    Disconnect,
}

//@todo Review which of these we need Mutexs/Arcs/etc. Might be over indulging here.
//@todo change the ID of this miner to the ID provided by the pool after subscribing/authing is
//done. Can just be a check in each one of those handles if the other one has already been
//completed.
#[derive(Debug)]
pub struct Connection {
    pub id: ID,
    pub write_half: Arc<Mutex<WriteHalf<TcpStream>>>,
    pub read_half: Arc<Mutex<BufReader<ReadHalf<TcpStream>>>>,
    pub authorized: Arc<Mutex<bool>>,
    pub session_start: SystemTime,
    pub connection_state: Mutex<ConnectionState>,
    pub subscribed: Arc<Mutex<bool>>,
    pub subscriber_id: Arc<Mutex<String>>,
    pub miner_info: Arc<RwLock<MinerInfo>>,
    //Possibly pull these out into their own var.
    //Makes it easier to operate on them.
    pub difficulty: Arc<Mutex<f64>>,
    pub submissions: Arc<Mutex<u64>>,
    pub last_retarget: Arc<Mutex<SystemTime>>,
    pub next_difficulty: Arc<Mutex<f64>>,
    pub job_stats: Arc<Mutex<JobStats>>,
    pub options: Arc<MinerOptions>,
    pub stats: Arc<Mutex<MinerStats>>,
    pub needs_ban: Arc<Mutex<bool>>,
    pub var_diff: bool,
    pub ban_stats: Arc<Mutex<BanStats>>,
    pub classic: Arc<Mutex<bool>>,
    pub last_message_id: Arc<Mutex<ID>>,
    pub worker_info: Arc<Mutex<WorkerInfo>>,
}

//@todo review this. I'm not sure if this is the best strategy here, but I'd like for the ability
//to pass some information to the implementer of traits. I.E. For logging in, the implementer
//probably wants the IP of the connection that is attempting to log in, so that they can rate limit
//or ban. Further, for share submitting and other features, the implementer probably wants the same
//ability. Rather than pass the entire stream into the trait functions, I figured we should build a
//struct that holds some information about the miner that can be edited and passed into those
//functions.
#[derive(Clone, Debug)]
pub struct MinerInfo {
    pub ip: IpAddr,
    pub auth: Option<MinerAuth>,
    pub id: Option<Uuid>,
    pub sid: Option<String>,
    pub job_stats: Option<MinerJobStats>,
    pub name: Option<String>,
}

#[derive(Clone, Debug)]
pub struct MinerAuth {
    pub id: String,
    pub username: String,
    pub client: String,
}

#[derive(Clone, Debug)]
pub struct MinerJobStats {
    pub expected_difficulty: f64,
}

//@todo probably move these over to types.
#[derive(Debug, Default)]
pub struct JobStats {
    last_share_timestamp: i64,
    last_retarget: i64,
    times: Vec<i64>,
    current_difficulty: f64,
    job_difficulty: f64,
}

//@todo this should probably come from builder pattern
#[derive(Debug, Default)]
pub struct MinerOptions {
    retarget_time: i64,
    target_time: f64,
    min_diff: f64,
    max_delta: f64,
    variance_percent: u32,
    share_time_min: f64,
    share_time_max: f64,
}

#[derive(Debug, Clone)]
pub struct MinerStats {
    accepted_shares: u64,
    rejected_shares: u64,
    last_active: NaiveDateTime,
}

#[derive(Debug)]
pub struct BanStats {
    accepted_shares: u64,
    rejected_shares: u64,
    last_active: NaiveDateTime,
}

#[derive(Debug, Clone, Default)]
pub struct WorkerInfo {
    pub client: Option<String>,
    pub name: Option<String>,
    pub sid: Option<String>,
    pub account_id: i32,
    id: Uuid,
}

impl Connection {
    pub fn new(
        addr: SocketAddr,
        rh: BufReader<ReadHalf<TcpStream>>,
        wh: WriteHalf<TcpStream>,
        var_diff: bool,
        initial_difficulty: f64,
        //@todo we should probably kill this, but for now it has to live here to make things
        //easier.
    ) -> Self {
        //@todo could store this as a UUID type as well.
        let id = Uuid::new_v4().to_string();

        info!("Accepting new miner. ID: {}", &id);

        let info = MinerInfo {
            ip: addr.ip(),
            auth: None,
            id: None,
            sid: None,
            job_stats: None,
            //@todo delete this as it's in WorkerInfo.
            name: None,
        };

        let options = MinerOptions {
            retarget_time: 120,
            target_time: 6.0,
            min_diff: 0.0001,
            max_delta: 1.0, //@todo make this adjustable, not sure if this is solid or not.
            //@todo probably don't store, get from above and then calcualte the others.
            variance_percent: 30,
            share_time_min: 4.2,
            share_time_max: 7.8,
        };

        //Make this an impl on stats same for each above. That way we can just do minerstats::new(current_time)
        let stats = MinerStats {
            accepted_shares: 0,
            rejected_shares: 0,
            last_active: Utc::now().naive_utc(),
        };

        let ban_stats = BanStats {
            accepted_shares: 0,
            rejected_shares: 0,
            last_active: Utc::now().naive_utc(),
        };

        Connection {
            id: ID::Str(id),
            write_half: Arc::new(Mutex::new(wh)),
            read_half: Arc::new(Mutex::new(rh)),
            authorized: Arc::new(Mutex::new(false)),
            session_start: SystemTime::now(),
            connection_state: Mutex::new(ConnectionState::Connected),
            subscribed: Arc::new(Mutex::new(false)),
            //@todo this should be passed in.
            difficulty: Arc::new(Mutex::new(initial_difficulty)),
            subscriber_id: Arc::new(Mutex::new(String::new())),
            miner_info: Arc::new(RwLock::new(info)),
            submissions: Arc::new(Mutex::new(0)),
            last_retarget: Arc::new(Mutex::new(SystemTime::now())),
            next_difficulty: Arc::new(Mutex::new(0.0)),
            job_stats: Arc::new(Mutex::new(Default::default())),
            options: Arc::new(options),
            stats: Arc::new(Mutex::new(stats)),
            var_diff,
            needs_ban: Arc::new(Mutex::new(false)),
            ban_stats: Arc::new(Mutex::new(ban_stats)),
            classic: Arc::new(Mutex::new(false)),
            last_message_id: Arc::new(Mutex::new(ID::Str(String::from("")))),
            worker_info: Arc::new(Mutex::new(Default::default())),
        }
    }

    pub async fn info(&self) -> MinerInfo {
        self.miner_info.read().await.clone()
    }

    pub async fn is_disconnected(&self) -> bool {
        *self.connection_state.lock().await == ConnectionState::Disconnect
    }

    pub async fn next_message(
        &self,
    ) -> Result<(String, serde_json::map::Map<String, serde_json::Value>)> {
        //I don't actually think this has to loop here.
        loop {
            let mut stream = self.read_half.lock().await;

            let mut buf = String::new();
            let num_bytes = stream.read_line(&mut buf).await?;

            if num_bytes == 0 {
                self.shutdown().await?;
                return Err(Error::StreamClosed);
            }

            if !buf.is_empty() {
                //@smells
                buf = buf.trim().to_owned();
                debug!("Received Message: {}", &buf);
                dbg!(&buf);
                let msg: Map<String, Value> = serde_json::from_str(&buf)?;

                let method = if msg.contains_key("method") {
                    match msg.get("method") {
                        Some(method) => method.as_str(),
                        //@todo need better stratum erroring here.
                        None => return Err(Error::MethodDoesntExist),
                    }
                } else if msg.contains_key("messsage") {
                    match msg.get("message") {
                        Some(method) => method.as_str(),
                        //@todo need better stratum erroring here.
                        None => return Err(Error::MethodDoesntExist),
                    }
                } else {
                    return Err(Error::MethodDoesntExist);
                };

                if let Some(method_string) = method {
                    return Ok((method_string.to_owned(), msg));
                } else {
                    //@todo improper format
                    return Err(Error::MethodDoesntExist);
                }
            };
        }
    }

    pub async fn send<T: Serialize>(&self, message: T) -> Result<()> {
        let msg = serde_json::to_vec(&message)?;
        let msg_string = serde_json::to_string(&message)?;

        debug!("Sending message: {}", msg_string);

        let mut stream = self.write_half.lock().await;

        stream.write_all(&msg).await?;
        stream.write_all(b"\n").await?;

        Ok(())
    }

    pub async fn shutdown(&self) -> Result<()> {
        *self.connection_state.lock().await = ConnectionState::Disconnect;

        //Only returning a result here because we might want to add more functionality in the
        //future.
        //Here is where we actually will write upstream to KILL the connection if we are using that
        //proxy.
        Ok(())
    }

    //Can probably not send avg here either.
    async fn retarget(&self, avg: f64, stats: &mut JobStats) -> Result<()> {
        // let mut stats = self.job_stats.lock().await;

        let mut new_difficulty = stats.current_difficulty * (self.options.target_time / avg);

        let delta = (new_difficulty - stats.current_difficulty).abs();

        if delta > self.options.max_delta {
            if new_difficulty > stats.current_difficulty {
                //@smells come back here later.
                new_difficulty = new_difficulty - (delta - self.options.max_delta);
            } else if new_difficulty < stats.current_difficulty {
                new_difficulty = new_difficulty + (delta - self.options.max_delta);
            }
        }

        if new_difficulty < self.options.min_diff {
            new_difficulty = self.options.min_diff;
        } else if new_difficulty > stats.job_difficulty {
            new_difficulty = stats.job_difficulty;
        }

        if new_difficulty < stats.current_difficulty || new_difficulty > stats.current_difficulty {
            stats.last_retarget = Utc::now().timestamp();

            //Clear some of the stats.
            stats.times = Vec::new();
            stats.current_difficulty = new_difficulty;
            let job_stats = MinerJobStats {
                expected_difficulty: new_difficulty,
            };
            self.miner_info.write().await.job_stats = Some(job_stats);

            // self.set_difficulty(stats.current_difficulty).await?;
        }

        Ok(())
    }

    //Unimplemented - Probably just log the value, and see what's going on.
    //Make a handle_unknown function that exists in stratum manager - then the pool can decide what
    //to do.
    pub async fn handle_unknown(&self, _msg: &serde_json::Value) -> Result<()> {
        Ok(())
    }

    pub async fn disconnect(&self) {
        *self.connection_state.lock().await = ConnectionState::Disconnect;
    }

    pub async fn ban(&self) {
        *self.needs_ban.lock().await = true;
    }

    pub async fn needs_ban(&self) -> bool {
        *self.needs_ban.lock().await
    }

    pub async fn get_stats(&self) -> MinerStats {
        self.stats.lock().await.clone()
    }

    pub async fn ip(&self) -> IpAddr {
        self.info().await.ip
    }

    // pub async fn id(&self) -> Uuid {
    //     self.info().await.id
    // }

    // ===== Worker Helper functions ===== //
    pub async fn set_worker_name(&self, name: Option<String>) {
        self.worker_info.lock().await.name = name;
    }

    pub async fn set_account_id(&self, id: i32) {
        self.worker_info.lock().await.account_id = id;
    }

    pub async fn get_account_id(&self) {
        self.worker_info.lock().await.account_id;
    }

    pub async fn set_client(&self, client: &str) {
        self.worker_info.lock().await.client = Some(client.to_owned());
    }

    pub async fn get_client(&self) -> Option<String> {
        self.worker_info.lock().await.client.clone()
    }

    pub async fn set_worker_id(&self, id: Uuid) {
        self.worker_info.lock().await.id = id;
    }

    pub async fn get_sid(&self) -> Option<String> {
        self.worker_info.lock().await.sid.clone()
    }

    pub async fn set_sid(&self, sid: &str) {
        self.worker_info.lock().await.sid = Some(sid.to_owned());
    }

    pub async fn get_worker(&self) -> WorkerInfo {
        self.worker_info.lock().await.clone()
    }

    //@todo make this a read/write
    pub async fn authorized(&self) -> bool {
        self.authorized.lock().await.clone()
    }

    pub async fn authorize(&self) {
        *self.authorized.lock().await = true;
    }

    //@todo make this a read/write
    pub async fn subscribed(&self) -> bool {
        self.subscribed.lock().await.clone()
    }

    pub async fn subscribe(&self) {
        *self.subscribed.lock().await = true;
    }

    pub async fn set_difficulty(&self, difficulty: f64) {
        *self.difficulty.lock().await = difficulty;
    }
}