use async_std::net::TcpStream;
use async_std::sync::{Arc, Mutex};
use futures::io::BufReader;
use futures::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt};
use futures::io::{ReadHalf, WriteHalf};
use log::info;
use serde::Serialize;
use std::time::SystemTime;
use stratum_types::params::{ClientParam, PoolParam};
use stratum_types::traits::{
    AuthManager, BlockValidator, DataProvider, StratumManager, SubscribeResult,
};
use stratum_types::traits::{PoolParams, StratumParams};
use stratum_types::Result;
use stratum_types::{
    ClientPacket, ClientRequest, ClientResponse, MinerInfo, PoolRequest, PoolResponse,
    StratumMethod,
};
use uuid::Uuid;

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

//@todo making difficulty variable would also be awesome.
//@todo Review which of these we need Mutexs/Arcs/etc. Might be over indulging here.
#[derive(Debug)]
pub struct Connection<SM: StratumManager> {
    pub id: String,
    pub write_half: Arc<Mutex<WriteHalf<TcpStream>>>,
    pub read_half: Arc<Mutex<BufReader<ReadHalf<TcpStream>>>>,
    pub authorized: Arc<Mutex<bool>>,
    pub data_provider: Arc<SM::DataProvider>,
    pub block_validator: Arc<SM::BlockValidator>,
    pub auth_manager: Arc<SM::AuthManager>,
    pub session_start: SystemTime,
    pub state: Mutex<State>,
    pub subscribed: Arc<Mutex<bool>>,
    pub difficulty: Arc<Mutex<f64>>,
    pub subscriber_id: Arc<Mutex<String>>,
}

impl<SM> Connection<SM>
where
    SM: StratumManager,
{
    pub fn new(
        stream: TcpStream,
        data_provider: Arc<SM::DataProvider>,
        auth_manager: Arc<SM::AuthManager>,
        block_validator: Arc<SM::BlockValidator>,
    ) -> 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 (rh, wh) = stream.split();
        Connection {
            id,
            write_half: Arc::new(Mutex::new(wh)),
            read_half: Arc::new(Mutex::new(BufReader::new(rh))),
            authorized: Arc::new(Mutex::new(false)),
            data_provider,
            auth_manager,
            block_validator,
            session_start: SystemTime::now(),
            state: Mutex::new(State::Connected),
            subscribed: Arc::new(Mutex::new(false)),
            difficulty: Arc::new(Mutex::new(0.0)),
            subscriber_id: Arc::new(Mutex::new(String::new())),
        }
    }

    pub async fn start(&self) -> Result<()> {
        loop {
            if *self.state.lock().await == State::Disconnect {
                break;
            }

            let msg: ClientPacket<SM::PoolParams, SM::StratumParams> = self.next_message().await?;

            match msg {
                ClientPacket::Request(req) => self.handle_requests(req).await?,
                ClientPacket::Response(res) => self.handle_responses(res).await?,
            };
        }

        Ok(())
    }

    pub async fn handle_requests(
        &self,
        req: ClientRequest<SM::PoolParams, SM::StratumParams>,
    ) -> Result<()> {
        if let ClientParam::Authorize(auth) = &req.params {
            return Ok(self.handle_authorize(auth).await?);
        }

        let authorized = self.authorized.lock().await;
        if !*authorized {
            //This would be a huge ban
            // return Err(Error::;
            //@todo needs to return an error here.
            return Ok(());
        }

        match &req.params {
            ClientParam::Submit(value) => self.handle_submit(value).await?,
            ClientParam::Subscribe(value) => self.handle_subscribe(value).await?,
            ClientParam::Unknown(value) => self.handle_unknown(value).await?,
            ClientParam::Authorize(_) => {}
        };
        Ok(())
    }

    pub async fn handle_responses(
        &self,
        _res: ClientResponse<SM::PoolParams, SM::StratumParams>,
    ) -> Result<()> {
        //@todo maybe throw this into a function - "checkAuth" then error is easier to throw
        let authorized = self.authorized.lock().await;
        if !*authorized {
            //This would be a huge ban
            // return Err(Error::;
            //@todo needs to return an error here.
            return Ok(());
        }

        Ok(())
    }

    //This needs to be either clientRequest OR clientResponse
    // pub async fn next_message(&self) -> Result<ClientRequest<SM::PoolParams, SM::StratumParams>> {
    pub async fn next_message(&self) -> Result<ClientPacket<SM::PoolParams, SM::StratumParams>> {
        loop {
            let mut stream = self.read_half.lock().await;

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

            if !buf.is_empty() {
                //@smells
                buf = buf.trim().to_owned();
                let msg: ClientPacket<SM::PoolParams, SM::StratumParams> =
                    serde_json::from_str(&buf)?;

                return Ok(msg);
            };
        }
    }

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

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

        stream.write_all(&msg).await?;

        //End the message here @todo not sure if this works.
        stream.write_all(b"\n").await?;

        Ok(())
    }

    //Helper function to make sending requests more simple.
    async fn send_request(
        &self,
        method: StratumMethod,
        params: PoolParam<SM::PoolParams, SM::StratumParams>,
    ) -> Result<()> {
        let request = PoolRequest {
            id: self.id.clone(),
            method,
            params,
        };

        Ok(self.send(request).await?)
    }

    async fn send_response(
        &self,
        method: StratumMethod,
        result: PoolParam<SM::PoolParams, SM::StratumParams>,
    ) -> Result<()> {
        let response = PoolResponse {
            id: self.id.clone(),
            method,
            result,
            error: None,
        };

        Ok(self.send(response).await?)
    }

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

        //Only returning a result here because we might want to add more functionality in the
        //future.
        Ok(())
    }

    // ===== Handler Functions ===== //
    pub async fn handle_authorize(
        &self,
        auth: &<SM::PoolParams as PoolParams>::Authorize,
    ) -> Result<()> {
        //@todo put this above into the struct
        let miner_info = Arc::new(MinerInfo {
            ip: "127.0.0.1".parse().unwrap(),
        });

        //@todo this needs to be either be forced to be a bool, or we need ot add a function here
        //that is authorized.is_authorized() so that we can set the internal auth to true.
        let authorized = self.auth_manager.authorize(miner_info, &auth).await?;

        self.send_response(
            StratumMethod::Authorize,
            PoolParam::AuthorizeResult(authorized),
        )
        .await?;

        // if authorized {
        //     *self.authorized.lock().await = authorized;
        // } else {
        //     self.shutdown().await?;
        // }
        // if authorized {
        *self.authorized.lock().await = true;
        info!("Authorized Miner: {}", &self.id);
        // } else {
        //     self.shutdown().await?;
        // }

        Ok(())
    }

    pub async fn send_work(&self) -> Result<()> {
        let job = self.data_provider.get_job().await?;

        self.send_request(StratumMethod::Notify, PoolParam::Notify(job))
            .await?;

        Ok(())
    }

    pub async fn handle_submit(
        &self,
        share: &<SM::StratumParams as StratumParams>::Submit,
    ) -> Result<()> {
        //@todo put this above into the struct
        let miner_info = Arc::new(MinerInfo {
            ip: "127.0.0.1".parse().unwrap(),
        });

        info!("Received share from miner: {}", &self.id);

        let valid = self
            .block_validator
            .validate_share(miner_info, share.clone())
            .await?;

        if valid {
            info!("Invalid share from miner: {} - Sending Reject", &self.id);
        } else {
            info!("Accepted share from miner: {}", &self.id);
        }

        // let response = PoolResponse {
        //     id: self.id.clone(),
        //     method: StratumMethod::Submit,
        //     result: PoolParams::SubmitResult(valid),
        //     error: None,
        // };

        // self.send(&response).await?;

        //Send a response to the miner @todo
        Ok(())
    }

    pub async fn handle_subscribe(
        &self,
        subscribe: &<SM::PoolParams as PoolParams>::Subscribe,
    ) -> Result<()> {
        //@todo put this above into the struct
        let miner_info = Arc::new(MinerInfo {
            ip: "127.0.0.1".parse().unwrap(),
        });

        let sub_info = self.auth_manager.subscribe(miner_info, subscribe).await?;

        *self.subscriber_id.lock().await = sub_info.id();

        *self.subscribed.lock().await = true;

        //2. Send the miner Subsription ID aka SubscribeResult response. save that the miner is
        //   subcribed
        self.send_response(
            StratumMethod::Subscribe,
            PoolParam::SubscribeResult(sub_info),
        )
        .await?;

        //3. Send the miner Set Difficulty and save it internally
        self.set_difficulty(0.5).await?; //@todo calulcate this dynamically.

        //4. Send the miner the current work
        self.send_work().await?;

        Ok(())
    }

    //This function sets the difficulty for this connection, and sends a set difficulty message to
    //the client.
    async fn set_difficulty(&self, difficulty: f64) -> Result<()> {
        //@todo some reasonable checks on this difficulty please.
        *self.difficulty.lock().await = difficulty;

        self.send_request(
            StratumMethod::SetDifficulty,
            PoolParam::SetDifficulty(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(())
    }
}