use crate::store::BaseData;
use rhai::{CustomType, TypeBuilder};
use serde::{Deserialize, Serialize};

/// Bid status enumeration
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub enum BidStatus {
    #[default]
    Pending,
    Confirmed,
    Assigned,
    Cancelled,
    Done,
}

/// Billing period enumeration
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub enum BillingPeriod {
    #[default]
    Hourly,
    Monthly,
    Yearly,
    Biannually,
    Triannually,
}

/// I can bid for infra, and optionally get accepted
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default, crate::DeriveObject)]
pub struct Bid {
    pub base_data: BaseData,
    /// links back to customer for this capacity (user on ledger)
    #[index]
    pub customer_id: u32,
    /// nr of slices I need in 1 machine
    pub compute_slices_nr: i32,
    /// price per 1 GB slice I want to accept
    pub compute_slice_price: f64,
    /// nr of storage slices needed
    pub storage_slices_nr: i32,
    /// price per 1 GB storage slice I want to accept
    pub storage_slice_price: f64,
    pub status: BidStatus,
    /// if obligation then will be charged and money needs to be in escrow, otherwise its an intent
    pub obligation: bool,
    /// epoch timestamp
    pub start_date: u32,
    /// epoch timestamp
    pub end_date: u32,
    /// signature as done by a user/consumer to validate their identity and intent
    pub signature_user: String,
    pub billing_period: BillingPeriod,
}

impl Bid {
    pub fn new() -> Self {
        Self {
            base_data: BaseData::new(),
            customer_id: 0,
            compute_slices_nr: 0,
            compute_slice_price: 0.0,
            storage_slices_nr: 0,
            storage_slice_price: 0.0,
            status: BidStatus::default(),
            obligation: false,
            start_date: 0,
            end_date: 0,
            signature_user: String::new(),
            billing_period: BillingPeriod::default(),
        }
    }

    pub fn customer_id(mut self, v: u32) -> Self {
        self.customer_id = v;
        self
    }
    
    pub fn compute_slices_nr(mut self, v: i32) -> Self {
        self.compute_slices_nr = v;
        self
    }
    
    pub fn compute_slice_price(mut self, v: f64) -> Self {
        self.compute_slice_price = v;
        self
    }
    
    pub fn storage_slices_nr(mut self, v: i32) -> Self {
        self.storage_slices_nr = v;
        self
    }
    
    pub fn storage_slice_price(mut self, v: f64) -> Self {
        self.storage_slice_price = v;
        self
    }
    
    pub fn status(mut self, v: BidStatus) -> Self {
        self.status = v;
        self
    }
    
    pub fn obligation(mut self, v: bool) -> Self {
        self.obligation = v;
        self
    }
    
    pub fn start_date(mut self, v: u32) -> Self {
        self.start_date = v;
        self
    }
    
    pub fn end_date(mut self, v: u32) -> Self {
        self.end_date = v;
        self
    }
    
    pub fn signature_user(mut self, v: impl ToString) -> Self {
        self.signature_user = v.to_string();
        self
    }
    
    pub fn billing_period(mut self, v: BillingPeriod) -> Self {
        self.billing_period = v;
        self
    }
}