use chrono::{DateTime, Utc};

use finance::error::{FinanceError, ReportError};

use sqlx::types::Uuid;

use supp_macro::command;

use crate::{config::ConfigError, user::User};

use super::{CmdError, CmdResult, PeriodData, ReportData, ReportFilter, ReportMeta};

mod fetch;

mod filter;

mod period;

mod tree;

#[cfg(test)]

mod command_tests;

#[cfg(test)]

mod unit_tests;

use fetch::{

    fetch_accounts, fetch_balance_splits_filtered_no_conversion,

    fetch_balance_splits_filtered_with_conversion, fetch_balance_splits_no_conversion,

    fetch_balance_splits_with_conversion, fetch_date_range_splits_filtered_no_conversion,

    fetch_date_range_splits_filtered_with_conversion, fetch_date_range_splits_no_conversion,

    fetch_date_range_splits_with_conversion, fetch_target_symbol,

};

use period::{generate_month_boundaries, generate_quarter_boundaries, generate_year_boundaries};

use tree::build_tree;

command! {

    BalanceReport {

        #[required]

        user_id: Uuid,

        #[optional]

        target_commodity_id: Uuid,

        #[optional]

        as_of: DateTime<Utc>,

        #[optional]

        report_filter: ReportFilter,

    } => {

        let user = User { id: user_id };

        let accounts = fetch_accounts(&mut conn).await?;

        let amounts = match (&target_commodity_id, &report_filter) {

            (Some(tid), Some(f)) => {

                let sym = fetch_target_symbol(&mut conn, *tid).await?;

                fetch_balance_splits_filtered_with_conversion(&mut conn, *tid, &sym, as_of, f).await?

            }

            (Some(tid), None) => {

                let sym = fetch_target_symbol(&mut conn, *tid).await?;

                fetch_balance_splits_with_conversion(&mut conn, *tid, &sym, as_of).await?

            }

            (None, Some(f)) => {

                fetch_balance_splits_filtered_no_conversion(&mut conn, as_of, f).await?

            }

            (None, None) => {

                fetch_balance_splits_no_conversion(&mut conn, as_of).await?

            }

        };

        let roots = build_tree(&accounts, &amounts);

        let period = PeriodData { label: None, roots };

        Ok(Some(CmdResult::Report(ReportData {

            meta: ReportMeta {

                date_from: None,

                date_to: as_of,

                target_commodity_id,

            },

            periods: vec![period],

        })))

    }

command! {

    IncomeExpenseReport {

        #[required]

        user_id: Uuid,

        #[required]

        date_from: DateTime<Utc>,

        #[required]

        date_to: DateTime<Utc>,

        #[optional]

        target_commodity_id: Uuid,

        #[optional]

        period_grouping: String,

        #[optional]

        report_filter: ReportFilter,

    } => {

        let user = User { id: user_id };

        let accounts = fetch_accounts(&mut conn).await?;

        let period_boundaries = match &period_grouping {

            Some(g) => match g.as_str() {

                "month" => generate_month_boundaries(date_from, date_to),

                "quarter" => generate_quarter_boundaries(date_from, date_to),

                "year" => generate_year_boundaries(date_from, date_to),

                other => return Err(CmdError::Finance(FinanceError::Report(

                    ReportError::InvalidPeriodGrouping(other.to_string()),

                ))),

            },

            None => vec![],

        };

        let periods = if period_boundaries.is_empty() {

            let amounts = match (&target_commodity_id, &report_filter) {

                (Some(tid), Some(f)) => {

                    let sym = fetch_target_symbol(&mut conn, *tid).await?;

                    fetch_date_range_splits_filtered_with_conversion(&mut conn, *tid, &sym, date_from, date_to, f).await?

                }

                (Some(tid), None) => {

                    let sym = fetch_target_symbol(&mut conn, *tid).await?;

                    fetch_date_range_splits_with_conversion(&mut conn, *tid, &sym, date_from, date_to).await?

                }

                (None, Some(f)) => {

                    fetch_date_range_splits_filtered_no_conversion(&mut conn, date_from, date_to, f).await?

                }

                (None, None) => {

                    fetch_date_range_splits_no_conversion(&mut conn, date_from, date_to).await?

                }

            };

            let roots = build_tree(&accounts, &amounts);

            vec![PeriodData { label: None, roots }]

        } else {

            let mut periods = Vec::new();

            for (label, pfrom, pto) in &period_boundaries {

                let amounts = match (&target_commodity_id, &report_filter) {

                    (Some(tid), Some(f)) => {

                        let sym = fetch_target_symbol(&mut conn, *tid).await?;

                        fetch_date_range_splits_filtered_with_conversion(&mut conn, *tid, &sym, *pfrom, *pto, f).await?

                    }

                    (Some(tid), None) => {

                        let sym = fetch_target_symbol(&mut conn, *tid).await?;

                        fetch_date_range_splits_with_conversion(&mut conn, *tid, &sym, *pfrom, *pto).await?

                    }

                    (None, Some(f)) => {

                        fetch_date_range_splits_filtered_no_conversion(&mut conn, *pfrom, *pto, f).await?

                    }

                    (None, None) => {

                        fetch_date_range_splits_no_conversion(&mut conn, *pfrom, *pto).await?

                    }

                };

                let roots = build_tree(&accounts, &amounts);

                periods.push(PeriodData {

                    label: Some(label.clone()),

                    roots,

                });

            }

            periods

        };

        Ok(Some(CmdResult::Report(ReportData {

            meta: ReportMeta {

                date_from: Some(date_from),

                date_to: Some(date_to),

                target_commodity_id,

            },

            periods,

        })))

    }

command! {

    TrialBalance {

        #[required]

        user_id: Uuid,

        #[required]

        date_from: DateTime<Utc>,

        #[required]

        date_to: DateTime<Utc>,

        #[optional]

        target_commodity_id: Uuid,

        #[optional]

        report_filter: ReportFilter,

    } => {

        let user = User { id: user_id };

        let accounts = fetch_accounts(&mut conn).await?;

        let amounts = match (&target_commodity_id, &report_filter) {

            (Some(tid), Some(f)) => {

                let sym = fetch_target_symbol(&mut conn, *tid).await?;

                fetch_date_range_splits_filtered_with_conversion(&mut conn, *tid, &sym, date_from, date_to, f).await?

            }

            (Some(tid), None) => {

                let sym = fetch_target_symbol(&mut conn, *tid).await?;

                fetch_date_range_splits_with_conversion(&mut conn, *tid, &sym, date_from, date_to).await?

            }

            (None, Some(f)) => {

                fetch_date_range_splits_filtered_no_conversion(&mut conn, date_from, date_to, f).await?

            }

            (None, None) => {

                fetch_date_range_splits_no_conversion(&mut conn, date_from, date_to).await?

            }

        };

        let roots = build_tree(&accounts, &amounts);

        let period = PeriodData { label: None, roots };

        Ok(Some(CmdResult::Report(ReportData {

            meta: ReportMeta {

                date_from: Some(date_from),

                date_to: Some(date_to),

                target_commodity_id,

            },

            periods: vec![period],

        })))

    }