use chrono::{DateTime, Utc};
use ulid::Ulid;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct AccountId(Ulid);

impl AccountId {
    pub fn as_ulid(&self) -> Ulid {
        self.0
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct PostingId(Ulid);

impl PostingId {
    pub fn as_ulid(&self) -> Ulid {
        self.0
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct JournalEntryId(Ulid);

impl JournalEntryId {
    pub fn as_ulid(&self) -> Ulid {
        self.0
    }
}

#[derive(PartialEq)]
pub enum AccountType {
    Asset,
    Liability,
    Equity,
    Revenue,
    Expense
}

pub struct Account {
    account_id: AccountId,
    pub account_type: AccountType,
    pub name: String,
    pub description: String
}

pub struct NewAccount {
    pub account_type: AccountType,
    pub name: String,
    pub description: String
}

impl NewAccount {
    fn new(account_type: AccountType, name: impl Into<String>, description: impl Into<String>) -> NewAccount {
        NewAccount {
            account_type,
            name: name.into(),
            description: description.into()
        }
    }
}

#[derive(PartialEq)]
pub enum PostingType {
    Debit,
    Credit
}

pub struct Posting {
    posting_id: PostingId,
    pub posting_type: PostingType,
    pub account_id: AccountId,
    pub amount: u64
}

pub struct NewPosting {
    pub posting_type: PostingType,
    pub account_id: AccountId,
    pub amount: u64
}

impl NewPosting {
    fn new(posting_type: PostingType, account_id: AccountId, amount: u64) -> NewPosting {
        NewPosting {
            posting_type,
            account_id,
            amount
        }
    }
}

pub struct JournalEntry {
    journal_entry_id: JournalEntryId,
    pub date: DateTime<Utc>,
    pub postings: Vec<Posting>,
    pub description: String
}

pub struct NewJournalEntry {
    pub date: DateTime<Utc>,
    pub postings: Vec<NewPosting>,
    pub description: String
}

impl NewJournalEntry {
    fn new(date: DateTime<Utc>, postings: Vec<NewPosting>, description: impl Into<String>) -> NewJournalEntry {
        NewJournalEntry {
            date,
            postings,
            description: description.into()
        }
    }
}