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 std::time::SystemTime;
use stratum_types::params::{
    AuthorizeParam, CapabilitiesParam, GetTransactionsParam, SubmitParam, SubscribeParam,
    SuggestDifficultyParam, SuggestTargetParam,
};
use stratum_types::params::{ClientParams, PoolParams};
use stratum_types::traits::{StratumManager, StratumPackets};
use stratum_types::Result;
use stratum_types::{ClientRequest, PoolResponse, StratumMethod};
use uuid::Uuid;

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

#[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 manager: Arc<SM>,
    pub session_start: SystemTime,
    pub state: Mutex<State>,
}

impl<SM> Connection<SM>
where
    SM: StratumManager,
{
    pub fn new(stream: TcpStream, manager: Arc<SM>) -> Self {
        //@todo could store this as a UUID type as well.
        let id = Uuid::new_v4().to_string();

        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)),
            manager,
            session_start: SystemTime::now(),
            state: Mutex::new(State::Connected),
        }
    }

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

            let msg: ClientRequest<SM::Params> = self.next_message().await?;

            //@todo see if we can speed things up with "continues" underneath each match section
            if let ClientParams::Authorize(auth) = &msg.params {
                self.handle_authorize(auth).await?;
                continue;
            }

            let authorized = self.authorized.lock().await;
            if !*authorized {
                break;
            }

            match &msg.params {
                ClientParams::Capabilities(value) => self.handle_capabilites(value).await?,
                ClientParams::ExtraNonceSubscribe => self.handle_extra_nonce_subscribe().await?,
                ClientParams::GetTransactions(value) => self.handle_get_transactions(value).await?,
                ClientParams::Submit(value) => self.handle_submit(value).await?,
                ClientParams::Subscribe(value) => self.handle_subscribe(value).await?,
                ClientParams::SuggestDifficulty(value) => {
                    self.handle_suggest_difficulty(value).await?
                }
                ClientParams::SuggestTarget(value) => self.handle_suggest_target(value).await?,
                ClientParams::Unknown(value) => self.handle_unknown(value).await?,
                ClientParams::Authorize(_) => {
                    continue;
                } // _ => {
                  //     break;
                  // }
            }
        }

        Ok(())
    }

    pub async fn next_message(&self) -> Result<ClientRequest<SM::Params>> {
        let mut stream = self.read_half.lock().await;

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

        let response: ClientRequest<SM::Params> = serde_json::from_str(&buf)?;

        Ok(response)
    }

    pub async fn send(&self, message: &PoolResponse<SM::Params>) -> 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(())
    }

    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,
        msg: &AuthorizeParam<<SM::Params as StratumPackets>::Authorize>,
    ) -> Result<()> {
        let authorized = self.manager.authorize(&msg.credentials).await?;

        let response = PoolResponse {
            id: self.id.clone(),
            method: StratumMethod::Authorize,
            result: PoolParams::AuthorizeResult(authorized),
            error: None,
        };

        self.send(&response).await?;

        if authorized {
            *self.authorized.lock().await = authorized;
        } else {
            self.shutdown().await?;
        }

        Ok(())
    }

    //@todo remove most likely.
    pub async fn handle_capabilites(
        &self,
        _msg: &CapabilitiesParam<<SM::Params as StratumPackets>::Capabilities>,
    ) -> Result<()> {
        Ok(())
    }

    //@todo remove most likely.
    pub async fn handle_extra_nonce_subscribe(&self) -> Result<()> {
        Ok(())
    }

    //@todo remove - unimplemented right now.
    pub async fn handle_get_transactions(&self, _msg: &GetTransactionsParam) -> Result<()> {
        Ok(())
    }

    pub async fn handle_submit(
        &self,
        msg: &SubmitParam<<SM::Params as StratumPackets>::Submit>,
    ) -> Result<()> {
        //@todo rename msg.submit to msg.share
        self.manager.submit(&msg.submit).await?;

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

    pub async fn handle_subscribe(
        &self,
        msg: &SubscribeParam<<SM::Params as StratumPackets>::Subscribe>,
    ) -> Result<()> {
        //@todo rename this to something that makes more sense
        self.manager.subscribe(&msg.subscribe).await?;

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

    //Unimplemented - @todo
    pub async fn handle_suggest_difficulty(
        &self,
        _msg: &SuggestDifficultyParam<<SM::Params as StratumPackets>::SuggestDifficulty>,
    ) -> Result<()> {
        Ok(())
    }

    //Unimplemented - @todo
    pub async fn handle_suggest_target(
        &self,
        _msg: &SuggestTargetParam<<SM::Params as StratumPackets>::SuggestTarget>,
    ) -> Result<()> {
        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(())
    }
}