dmc-dsg 0.1.4

use cyfs_base::*;
use serde::{Serialize, Deserialize};

pub enum JsonProtocol {
    CreatePushTask,
    CreatePushTaskResp,
    CreatePullTask,
    CreatePullTaskResp,
    GetPushTaskState,
    GetPushTaskStateResp,
    GetDMCAccount,
    GetDMCAccountResp,
    SetDMCAccount,
    SetDMCAccountResp,
    ReportCyfsInfo,
    ReportCyfsInfoResp,
    AddMerkle,
    AddMerkleResp,
    ChallengeResp,
    ChallengeRespResp,
    Arbitration,
    ArbitrationResp,
    GetTaskList,
    GetTaskListResp,
    GetTaskChunkList,
    GetTaskChunkListResp,
    SetMinerDecId,
    SetMinerDecIdResp,
    Stack,
    StackResp,
    Bill,
    BillResp,
    Mint,
    MintResp,
    GetPullTaskState,
    GetPullTaskStateResp,
    Recovery,
    RecoveryResp,
    GetRecoveryState,
    GetRecoveryStateResp,
}

#[derive(Serialize, Deserialize, Copy, Clone, RawEncode, RawDecode, Eq, PartialEq)]
pub enum StoreType {
    Backup,
    Cache
}

impl ToString for StoreType {
    fn to_string(&self) -> String {
        match self {
            StoreType::Backup => {"Backup".to_string()}
            StoreType::Cache => {"Cache".to_string()}
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct CreatePushTask {
    pub chunk_list: Vec<String>,
    pub http_url: Option<String>,
    pub store_type: StoreType,
    pub dmc_account: Option<String>,
}

#[derive(Serialize, Deserialize)]
pub struct CreatePullTask {
    pub task_id: String,
}

#[derive(Serialize, Deserialize, RawEncode, RawDecode)]
pub enum DsgPushTaskState {
    WaitingSpace,
    Syncing(Vec<(String, String, String)>),
    Finished(Vec<(String, String, String, String)>),
    Error(String),
}

#[derive(Serialize, Deserialize, RawEncode, RawDecode)]
pub enum DsgPullTaskState {
    Init,
    Downloading,
    Finished,
    Err(String)
}

#[derive(Serialize, Deserialize)]
pub struct AddMerkleReq {
    pub order_id: String,
    pub merkle_root: String,
    pub data_block_count: u64,
}

#[derive(Serialize, Deserialize)]
pub struct ChallengeRespReq {
    pub order_id: String,
    pub reply_hash: String,
}

#[derive(Serialize, Deserialize)]
pub struct ArbitrationReq {
    pub order_id: String,
    pub data: Vec<u8>,
    pub cut_merkle: Vec<String>
}

#[derive(Serialize, Deserialize)]
pub struct GetTaskList {
    pub offset: u64,
    pub length: u64,
}

#[derive(Serialize, Deserialize)]
pub struct ResultList<T: Serialize + for<'a> Deserialize<'a>> {
    pub sum: u64,
    #[serde(bound(deserialize = "Vec<T>: for<'a> Deserialize<'a>"))]
    pub list: Vec<T>
}

#[derive(Serialize, Deserialize)]
pub struct GetTaskChunkList {
    pub task_id: String,
}

#[derive(Serialize, Deserialize)]
pub struct SetDMCAccount {
    pub dmc_account: String,
    pub dmc_key: String,
}

#[derive(Serialize, Deserialize)]
pub struct BillReq {
    pub asset: String,
    pub price: f64,
    pub memo: String,
}

#[derive(RawDecode, RawEncode, Clone, Serialize, Deserialize)]
pub enum DsgRecoveryTaskState {
    Init,
    Recovering,
    Finished(Vec<(String, String)>),
    Err(String)
}