use chrono::{DateTime, Utc};

use sqlx::types::Uuid;

use supp_macro::command;

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

use super::super::{

    ActivityData, ActivityGroup, ActivityGroupResult, ActivityPeriod, CmdError, CmdResult,

    FilterEntity, PeriodGrouping, ReportFilter, ReportMeta,

};

use super::fetch::{

    fetch_accounts, fetch_date_range_splits_filtered_no_conversion,

    fetch_date_range_splits_filtered_with_conversion, fetch_target_symbol,

};

use super::period::boundaries;

/// Queries a single activity report may issue.

///

/// The report runs one query per period per group; 4096 is already far past a

/// readable report and keeps one request off a cluster shared with other

/// tenants.

pub(super) const MAX_QUERIES: usize = 4096;

use super::tree::build_tree;

// TODO(script-classifier): swap this helper for one that evaluates a

// user-supplied nomiscript expression returning a Vec<ActivityGroup>. See

// doc/reporting.org "Future work" for the intent.

    ]

/// Leaves in the largest query this report will run.

///

/// The MAX, not the sum: each query is `And(group.filter, report_filter)` for

/// ONE group (see [`compose_group_filter`]), so summing across groups measures

/// a cost no query ever incurs. How MANY groups there are is bounded separately,

/// by the query budget.

    }

        }

    }

struct RunCtx<'a> {

    accounts: &'a [super::tree::AccountRow],

    user_filter: Option<&'a ReportFilter>,

    target_commodity_id: Option<Uuid>,

    target_symbol: Option<&'a str>,

}

command! {

    ActivityReport {

        #[required]

        user_id: Uuid,

        #[required]

        date_from: DateTime<Utc>,

        #[required]

        date_to: DateTime<Utc>,

        #[optional]

        target_commodity_id: Uuid,

        #[optional]

        period_grouping: PeriodGrouping,

        #[optional]

        groups: Vec<ActivityGroup>,

        #[optional]

        report_filter: ReportFilter,

    } => {

        let user = User { id: user_id };

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

        let groups = groups.unwrap_or_else(default_activity_groups);

        let target_symbol = match target_commodity_id {

            Some(tid) => Some(fetch_target_symbol(&mut conn, tid).await?),

            None => None,

        };

        super::period::check_range(date_from, date_to)?;

        let period_boundaries = period_grouping

            .transpose()?

            .unwrap_or_default();

        // The loop below runs one query per period PER GROUP, and both factors

        // come from the caller: `groups` is JSON on the query string with no

        // length of its own. Bounding only the periods leaves the product

        // unbounded, which is the whole defect over again.

        super::period::query_budget(period_boundaries.len(), groups.len(), MAX_QUERIES)?;

        super::filter::check_filter_size(widest_query_leaves(report_filter.as_ref(), &groups))?;

        let ctx = RunCtx {

            accounts: &accounts,

            user_filter: report_filter.as_ref(),

            target_commodity_id,

            target_symbol: target_symbol.as_deref(),

        };

        let periods = if period_boundaries.is_empty() {

            let mut group_results = Vec::with_capacity(groups.len());

            for group in &groups {

                group_results.push(

                    run_group_for_period(&mut conn, &ctx, group, date_from, date_to).await?,

                );

            }

            vec![ActivityPeriod {

                label: None,

                groups: group_results,

            }]

        } else {

            let mut out = Vec::with_capacity(period_boundaries.len());

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

                let mut group_results = Vec::with_capacity(groups.len());

                for group in &groups {

                    group_results

                        .push(run_group_for_period(&mut conn, &ctx, group, *pfrom, *pto).await?);

                }

                out.push(ActivityPeriod {

                    label: Some(label.clone()),

                    groups: group_results,

                });

            }

            out

        };

        Ok(Some(CmdResult::Activity(ActivityData {

            meta: ReportMeta {

                date_from: Some(date_from),

                date_to: Some(date_to),

                target_commodity_id,

            },

            periods,

        })))

    }