ocpi_tariffs/

generate.rs

mod v2x;

use std::{
    borrow::Cow,
    cmp::{max, min},
    fmt,
    ops::Range,
};

use chrono::{DateTime, Datelike as _, NaiveDateTime, NaiveTime, TimeDelta, Utc};
use rust_decimal::{prelude::ToPrimitive, Decimal};
use rust_decimal_macros::dec;

use crate::{
    country, currency,
    duration::ToHoursDecimal,
    energy::{Ampere, Kw, Kwh},
    from_warning_all, into_caveat, into_caveat_all,
    json::FromJson as _,
    number::{FromDecimal as _, RoundDecimal},
    price, tariff,
    warning::{self, GatherWarnings as _, IntoCaveat, WithElement as _},
    Price, Version, Versioned,
};

/// The minimum duration of a CDR. Anything below this will result in an Error.
const MIN_CS_DURATION_SECS: i64 = 120;

type DateTimeSpan = Range<DateTime<Utc>>;
type Verdict<T> = crate::Verdict<T, WarningKind>;
pub type Caveat<T> = warning::Caveat<T, WarningKind>;

/// Return the value if `Some`. Otherwise, bail(return) with an `Error::Internal` containing the giving message.
macro_rules! some_dec_or_bail {
    ($elem:expr, $opt:expr, $warnings:expr, $msg:literal) => {
        match $opt {
            Some(v) => v,
            None => {
                return $warnings.bail(WarningKind::Decimal($msg), $elem.as_element());
            }
        }
    };
}

/// The outcome of calling [`crate::cdr::generate_from_tariff`].
#[derive(Debug)]
pub struct Report {
    /// The ID of the parsed tariff.
    pub tariff_id: String,

    // The currency code of the parsed tariff.
    pub tariff_currency_code: currency::Code,

    /// A partial CDR that can be fleshed out by the caller.
    ///
    /// The CDR is partial as not all required fields are set as the `cdr_from_tariff` function
    /// does not know anything about the EVSE location or the token used to authenticate the chargesession.
    ///
    /// * See: [OCPI spec 2.2.1: CDR](<https://github.com/ocpi/ocpi/blob/release-2.2.1-bugfixes/mod_cdrs.asciidoc>)
    pub partial_cdr: PartialCdr,
}

/// A partial CDR generated by the `cdr_from_tariff` function.
///
/// The CDR is partial as not all required fields are set as the `cdr_from_tariff` function
/// does not know anything about the EVSE location or the token used to authenticate the chargesession.
///
/// * See: [OCPI spec 2.2.1: CDR](<https://github.com/ocpi/ocpi/blob/release-2.2.1-bugfixes/mod_cdrs.asciidoc>)
/// * See: [OCPI spec 2.1.1: Tariff](https://github.com/ocpi/ocpi/blob/release-2.1.1-bugfixes/mod_tariffs.md)
#[derive(Debug)]
pub struct PartialCdr {
    /// ISO-3166 alpha-2 country code of the CPO that 'owns' this CDR.
    pub cpo_country_code: Option<country::Code>,

    /// ISO-3166 alpha-2 country code of the CPO that 'owns' this CDR.
    pub cpo_currency_code: currency::Code,

    /// ID of the CPO that 'owns' this CDR (following the ISO-15118 standard).
    pub party_id: Option<String>,

    /// Start timestamp of the charging session.
    pub start_date_time: DateTime<Utc>,

    /// End timestamp of the charging session.
    pub end_date_time: DateTime<Utc>,

    /// Total energy charged, in kWh.
    pub total_energy: Option<Kwh>,

    /// Total time charging.
    pub total_charging_duration: Option<TimeDelta>,

    /// Total time not charging.
    pub total_parking_duration: Option<TimeDelta>,

    /// Total cost of this transaction.
    pub total_cost: Option<Price>,

    /// Total cost related to the energy dimension.
    pub total_energy_cost: Option<Price>,

    /// Total cost of the flat dimension.
    pub total_fixed_cost: Option<Price>,

    /// Total cost related to the parking time dimension.
    pub total_parking_duration_cost: Option<Price>,

    /// Total cost related to the charging time dimension.
    pub total_charging_duration_cost: Option<Price>,

    /// List of charging periods that make up this charging session. A session should consist of 1 or
    /// more periods, where each period has a different relevant Tariff.
    pub charging_periods: Vec<ChargingPeriod>,
}

/// A single charging period, containing a nonempty list of charge dimensions.
///
/// * See: [OCPI spec 2.2.1: CDR ChargingPeriod](<https://github.com/ocpi/ocpi/blob/release-2.2.1-bugfixes/mod_cdrs.asciidoc#146-chargingperiod-class>)
#[derive(Debug)]
pub struct ChargingPeriod {
    /// Start timestamp of the charging period. This period ends when a next period starts, the
    /// last period ends when the session ends
    pub start_date_time: DateTime<Utc>,

    /// List of relevant values for this charging period.
    pub dimensions: Vec<Dimension>,

    /// Unique identifier of the Tariff that is relevant for this Charging Period.
    /// In the OCPI spec the `tariff_id` field is optional but, we always know the tariff ID
    /// when generating a CDR.
    pub tariff_id: Option<String>,
}

/// The volume that has been consumed for a specific dimension during a charging period.
///
/// * See: [OCPI spec 2.2.1: CDR Dimension](<https://github.com/ocpi/ocpi/blob/release-2.2.1-bugfixes/mod_cdrs.asciidoc#mod_cdrs_cdrdimension_class>)
#[derive(Debug)]
pub struct Dimension {
    pub dimension_type: DimensionType,

    /// Volume of the dimension consumed, measured according to the dimension type.
    pub volume: Decimal,
}

/// The volume that has been consumed for a specific dimension during a charging period.
///
/// * See: [OCPI spec 2.2.1 CDR DimensionType](<https://github.com/ocpi/ocpi/blob/release-2.2.1-bugfixes/mod_cdrs.asciidoc#mod_cdrs_cdrdimension_class>)
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DimensionType {
    /// Consumed energy in `kWh`.
    Energy,
    /// The peak current, in 'A', during this period.
    MaxCurrent,
    /// The lowest current, in `A`, during this period.
    MinCurrent,
    /// The maximum power, in 'kW', reached during this period.
    MaxPower,
    /// The minimum power, in 'kW', reached during this period.
    MinPower,
    /// The parking time, in hours, consumed in this period.
    ParkingTime,
    /// The reservation time, in hours, consumed in this period.
    ReservationTime,
    /// The charging time, in hours, consumed in this period.
    Time,
}

into_caveat_all!(Report, Timeline);

/// Generate a CDR from a given tariff.
pub fn cdr_from_tariff(tariff_elem: &tariff::Versioned<'_>, config: Config) -> Verdict<Report> {
    let mut warnings = warning::Set::new();
    // To generate a CDR from a tariff first, the tariff is parsed into structured data.
    // Then some broad metrics are calculated that define limits on the chargesession.
    //
    // A Timeline of Events is then constructed by generating Events for each Element and each restriction.
    // Some restrictions are periodic and can result in many `Event`s.
    //
    // The `Timeline` of `Event`s are then sorted by time and converted into a list of `ChargePeriods`.
    let (metrics, timezone) = metrics(tariff_elem, config)?.gather_warnings_into(&mut warnings);

    let tariff = match tariff_elem.version() {
        Version::V211 => {
            let tariff = tariff::v211::Tariff::from_json(tariff_elem.as_element())?
                .gather_warnings_into(&mut warnings);

            tariff::v221::Tariff::from(tariff)
        }
        Version::V221 => tariff::v221::Tariff::from_json(tariff_elem.as_element())?
            .gather_warnings_into(&mut warnings),
    };

    if !is_tariff_active(&metrics.start_date_time, &tariff) {
        warnings.with_elem(
            tariff::WarningKind::NotActive.into(),
            tariff_elem.as_element(),
        );
    }

    let timeline = timeline(timezone, &metrics, &tariff);
    let mut charging_periods = charge_periods(&metrics, timeline);

    let report = price::periods(
        metrics.end_date_time,
        timezone,
        &tariff,
        &mut charging_periods,
    )
    .with_element(tariff_elem.as_element())?
    .gather_warnings_into(&mut warnings);

    let price::PeriodsReport {
        billable: _,
        periods,
        totals,
        total_costs,
    } = report;

    let charging_periods = periods
        .into_iter()
        .map(|period| {
            let price::PeriodReport {
                start_date_time,
                end_date_time: _,
                dimensions,
            } = period;
            let time = dimensions
                .duration_charging
                .volume
                .as_ref()
                .map(|dt| Dimension {
                    dimension_type: DimensionType::Time,
                    volume: ToHoursDecimal::to_hours_dec(dt),
                });
            let parking_time = dimensions
                .duration_parking
                .volume
                .as_ref()
                .map(|dt| Dimension {
                    dimension_type: DimensionType::ParkingTime,
                    volume: ToHoursDecimal::to_hours_dec(dt),
                });
            let energy = dimensions.energy.volume.as_ref().map(|kwh| Dimension {
                dimension_type: DimensionType::Energy,
                volume: (*kwh).into(),
            });
            let dimensions = vec![energy, parking_time, time]
                .into_iter()
                .flatten()
                .collect();

            ChargingPeriod {
                start_date_time,
                dimensions,
                tariff_id: Some(tariff.id.to_string()),
            }
        })
        .collect();

    let mut total_cost = total_costs.total();

    if let Some(total_cost) = total_cost.as_mut() {
        if let Some(min_price) = tariff.min_price {
            if *total_cost < min_price {
                *total_cost = min_price;
                warnings.with_elem(
                    tariff::WarningKind::TotalCostClampedToMin.into(),
                    tariff_elem.as_element(),
                );
            }
        }

        if let Some(max_price) = tariff.max_price {
            if *total_cost > max_price {
                *total_cost = max_price;
                warnings.with_elem(
                    tariff::WarningKind::TotalCostClampedToMin.into(),
                    tariff_elem.as_element(),
                );
            }
        }
    }

    let report = Report {
        tariff_id: tariff.id.to_string(),
        tariff_currency_code: tariff.currency,
        partial_cdr: PartialCdr {
            cpo_country_code: tariff.country_code,
            party_id: tariff.party_id.as_ref().map(ToString::to_string),
            start_date_time: metrics.start_date_time,
            end_date_time: metrics.end_date_time,
            cpo_currency_code: tariff.currency,
            total_energy: totals.energy.round_to_ocpi_scale(),
            total_charging_duration: totals.duration_charging,
            total_parking_duration: totals.duration_parking,
            total_cost: total_cost.round_to_ocpi_scale(),
            total_energy_cost: total_costs.energy.round_to_ocpi_scale(),
            total_fixed_cost: total_costs.fixed.round_to_ocpi_scale(),
            total_parking_duration_cost: total_costs.duration_parking.round_to_ocpi_scale(),
            total_charging_duration_cost: total_costs.duration_charging.round_to_ocpi_scale(),
            charging_periods,
        },
    };

    Ok(report.into_caveat(warnings))
}

/// Make a `Timeline` of `Event`s using the `Metric`s and `Tariff`.
fn timeline(
    timezone: chrono_tz::Tz,
    metrics: &Metrics,
    tariff: &tariff::v221::Tariff<'_>,
) -> Timeline {
    let mut events = vec![];

    let Metrics {
        start_date_time: cdr_start,
        end_date_time: cdr_end,
        duration_charging,
        duration_parking,
        max_power_supply,
        max_current_supply,

        energy_supplied: _,
    } = metrics;

    events.push(Event {
        duration_from_start: TimeDelta::seconds(0),
        kind: EventKind::SessionStart,
    });

    events.push(Event {
        duration_from_start: *duration_charging,
        kind: EventKind::ChargingEnd,
    });

    if let Some(duration_parking) = duration_parking {
        events.push(Event {
            duration_from_start: *duration_parking,
            kind: EventKind::ParkingEnd {
                start: metrics.duration_charging,
            },
        });
    }

    // True if `min_current` or `max_current` restrictions are defined.
    // Then we set current to be consumed for each period.
    let mut emit_current = false;

    // True if `min_power` or `max_power` restrictions are defined.
    // Then we set power to be consumed for each period.
    let mut emit_power = false;

    for elem in &tariff.elements {
        if let Some((time_restrictions, energy_restrictions)) = elem
            .restrictions
            .as_ref()
            .map(tariff::v221::Restrictions::restrictions_by_category)
        {
            let mut time_events =
                generate_time_events(timezone, *cdr_start..*cdr_end, time_restrictions);

            let v2x::EnergyRestrictions {
                min_kwh,
                max_kwh,
                min_current,
                max_current,
                min_power,
                max_power,
            } = energy_restrictions;

            if !emit_current {
                // If the generator current is contained within the restriction, then we set
                // an amount of current to be consumed for each period.
                //
                // Note: The generator supplies maximum current.
                emit_current = (min_current..=max_current).contains(&Some(*max_current_supply));
            }

            if !emit_power {
                // If the generator power is contained within the restriction, then we set
                // an amount of power to be consumed for each period.
                //
                // Note: The generator supplies maximum power.
                emit_power = (min_power..=max_power).contains(&Some(*max_power_supply));
            }

            let mut energy_events = generate_energy_events(
                metrics.duration_charging,
                metrics.energy_supplied,
                min_kwh,
                max_kwh,
            );

            events.append(&mut time_events);
            events.append(&mut energy_events);
        }
    }

    Timeline {
        events,
        emit_current,
        emit_power,
    }
}

/// Generate a list of `Event`s based on the `TimeRestrictions` an `Element` has.
fn generate_time_events(
    timezone: chrono_tz::Tz,
    cdr_span: DateTimeSpan,
    restrictions: v2x::TimeRestrictions,
) -> Vec<Event> {
    const MIDNIGHT: NaiveTime = NaiveTime::from_hms_opt(0, 0, 0)
        .expect("The hour, minute and second values are correct and hardcoded");
    const ONE_DAY: TimeDelta = TimeDelta::days(1);

    let v2x::TimeRestrictions {
        start_time,
        end_time,
        start_date,
        end_date,
        min_duration,
        max_duration,
        weekdays,
    } = restrictions;
    let mut events = vec![];

    let cdr_duration = cdr_span.end - cdr_span.start;

    // If `min_duration` occur within the duration of the chargesession add an event.
    if let Some(min_duration) = min_duration.filter(|dt| &cdr_duration < dt) {
        events.push(Event {
            duration_from_start: min_duration,
            kind: EventKind::MinDuration,
        });
    }

    // If `max_duration` occur within the duration of the chargesession add an event.
    if let Some(max_duration) = max_duration.filter(|dt| &cdr_duration < dt) {
        events.push(Event {
            duration_from_start: max_duration,
            kind: EventKind::MaxDuration,
        });
    }

    // Here we create the `NaiveDateTime` range by combining the `start_date` (`NaiveDate`) and
    // `start_time` (`NaiveTime`) and the associated `end_date` and `end_time`.
    //
    // If `start_time` or `end_time` are `None` then their respective `NaiveDate` is combined
    // with the `NaiveTime` of `00:00:00` to form a `NaiveDateTime`.
    //
    // If the `end_time < start_time` then the period wraps around to the following day.
    //
    // See: <https://github.com/ocpi/ocpi/blob/release-2.2.1-bugfixes/mod_tariffs.asciidoc#146-tariffrestrictions-class>
    let (start_date_time, end_date_time) =
        if let (Some(start_time), Some(end_time)) = (start_time, end_time) {
            if end_time < start_time {
                (
                    start_date.map(|d| d.and_time(start_time)),
                    end_date.map(|d| d.and_time(end_time + ONE_DAY)),
                )
            } else {
                (
                    start_date.map(|d| d.and_time(start_time)),
                    end_date.map(|d| d.and_time(end_time)),
                )
            }
        } else {
            (
                start_date.map(|d| d.and_time(start_time.unwrap_or(MIDNIGHT))),
                end_date.map(|d| d.and_time(end_time.unwrap_or(MIDNIGHT))),
            )
        };

    // If `start_date` or `end_date` is set we clamp the cdr_span to those dates.
    // As we are not going to produce any events before `start_date` or after `end_date`.
    let event_span = clamp_date_time_span(
        start_date_time.and_then(|d| local_to_utc(timezone, d)),
        end_date_time.and_then(|d| local_to_utc(timezone, d)),
        cdr_span,
    );

    if let Some(start_time) = start_time {
        let mut start_events =
            gen_naive_time_events(&event_span, start_time, &weekdays, EventKind::StartTime);
        events.append(&mut start_events);
    }

    if let Some(end_time) = end_time {
        let mut end_events =
            gen_naive_time_events(&event_span, end_time, &weekdays, EventKind::EndTime);
        events.append(&mut end_events);
    }

    events
}

/// Convert a `NaiveDateTime` to a `DateTime<Utc>` using the local timezone.
///
/// Return Some `DateTime<Utc>` if the conversion from `NaiveDateTime` results in either a single
/// or ambiguous `DateTime`. If the conversion is _ambiguous_ due to a _fold_ in the local time,
/// then we return the earliest `DateTime`.
fn local_to_utc(timezone: chrono_tz::Tz, date_time: NaiveDateTime) -> Option<DateTime<Utc>> {
    use chrono::offset::LocalResult;

    let result = date_time.and_local_timezone(timezone);

    let local_date_time = match result {
        LocalResult::Single(d) => d,
        LocalResult::Ambiguous(earliest, _latest) => earliest,
        LocalResult::None => return None,
    };

    Some(local_date_time.to_utc())
}

/// Generate `Event`s for the `start_time` or `end_time` restriction.
fn gen_naive_time_events(
    event_span: &Range<DateTime<Utc>>,
    time: NaiveTime,
    weekdays: &v2x::WeekdaySet,
    kind: EventKind,
) -> Vec<Event> {
    let mut events = vec![];
    let time_delta = time - event_span.start.time();
    let cdr_duration = event_span.end - event_span.start;

    // If the start time is before the CDR start, we move it forward 24hours
    // and test again.
    let time_delta = if time_delta.num_seconds().is_negative() {
        let time_delta = time + TimeDelta::days(1);
        time_delta - event_span.start.time()
    } else {
        time_delta
    };

    // If the start delta is still negative after moving it forward 24 hours
    if time_delta.num_seconds().is_negative() {
        return vec![];
    }

    // The time is after the CDR start.
    let remainder = cdr_duration - time_delta;

    if remainder.num_seconds().is_positive() {
        let duration_from_start = time_delta;
        let date = event_span.start + duration_from_start;

        if weekdays.contains(date.weekday()) {
            // The time is before the CDR end.
            events.push(Event {
                duration_from_start: time_delta,
                kind,
            });
        }

        for day in 1..=remainder.num_days() {
            let duration_from_start = time_delta + TimeDelta::days(day);
            let date = event_span.start + duration_from_start;

            if weekdays.contains(date.weekday()) {
                events.push(Event {
                    duration_from_start,
                    kind,
                });
            }
        }
    }

    events
}

/// Generate a list of `Event`s based on the `TimeRestrictions` an `Element` has.
fn generate_energy_events(
    duration_charging: TimeDelta,
    energy_supplied: Kwh,
    min_kwh: Option<Kwh>,
    max_kwh: Option<Kwh>,
) -> Vec<Event> {
    let mut events = vec![];

    if let Some(duration_from_start) =
        min_kwh.and_then(|kwh| energy_factor(kwh, energy_supplied, duration_charging))
    {
        events.push(Event {
            duration_from_start,
            kind: EventKind::MinKwh,
        });
    }

    if let Some(duration_from_start) =
        max_kwh.and_then(|kwh| energy_factor(kwh, energy_supplied, duration_charging))
    {
        events.push(Event {
            duration_from_start,
            kind: EventKind::MaxKwh,
        });
    }

    events
}

fn energy_factor(power: Kwh, power_total: Kwh, duration_total: TimeDelta) -> Option<TimeDelta> {
    use rust_decimal::prelude::ToPrimitive;

    // Find the time that the `min_kwh` amount of power was reached.
    // It has to be within the charging time.
    let power = Decimal::from(power);
    // The total power supplied during the chargesession
    let power_total = Decimal::from(power_total);
    // The factor minimum of the total power supplied.
    let factor = power_total / power;

    if factor.is_sign_negative() || factor > dec!(1.0) {
        return None;
    }

    let duration_from_start = factor * Decimal::from(duration_total.num_seconds());
    duration_from_start.to_i64().map(TimeDelta::seconds)
}

/// Generate a list of charging periods for the given tariffs timeline.
fn charge_periods(metrics: &Metrics, timeline: Timeline) -> Vec<price::Period> {
    /// Keep track of the whether we are charging or parking.
    enum ChargingPhase {
        Charging,
        Parking,
    }

    let Metrics {
        start_date_time: cdr_start,
        max_power_supply,
        max_current_supply,

        end_date_time: _,
        duration_charging: _,
        duration_parking: _,
        energy_supplied: _,
    } = metrics;

    let Timeline {
        mut events,
        emit_current,
        emit_power,
    } = timeline;

    events.sort_unstable_by_key(|e| e.duration_from_start);

    let mut periods = vec![];
    let emit_current = emit_current.then_some(*max_current_supply);
    let emit_power = emit_power.then_some(*max_power_supply);
    // Charging starts instantly in this model.
    let mut charging_phase = ChargingPhase::Charging;

    for items in events.windows(2) {
        let [event, event_next] = items else {
            unreachable!("The window size is 2");
        };

        let Event {
            duration_from_start,
            kind,
        } = event;

        if let EventKind::ChargingEnd = kind {
            charging_phase = ChargingPhase::Parking;
        }

        let duration = event_next.duration_from_start - *duration_from_start;
        let start_date_time = *cdr_start + *duration_from_start;

        let consumed = if let ChargingPhase::Charging = charging_phase {
            let energy = Decimal::from(*max_power_supply) * duration.to_hours_dec();
            price::Consumed {
                duration_charging: Some(duration),
                duration_parking: None,
                energy: Some(Kwh::from_decimal(energy)),
                current_max: emit_current,
                current_min: emit_current,
                power_max: emit_power,
                power_min: emit_power,
            }
        } else {
            price::Consumed {
                duration_charging: None,
                duration_parking: Some(duration),
                energy: None,
                current_max: None,
                current_min: None,
                power_max: None,
                power_min: None,
            }
        };

        let period = price::Period {
            start_date_time,
            consumed,
        };

        periods.push(period);
    }

    periods
}

/// A `DateTimeSpan` bounded by a minimum and a maximum
///
/// If the input `DateTimeSpan` is less than `min_date` then this returns `min_date`.
/// If input is greater than `max_date` then this returns `max_date`.
/// Otherwise, this returns input `DateTimeSpan`.
fn clamp_date_time_span(
    min_date: Option<DateTime<Utc>>,
    max_date: Option<DateTime<Utc>>,
    span: DateTimeSpan,
) -> DateTimeSpan {
    // Make sure the `min_date` is the earlier of the `min`, max pair.
    let (min_date, max_date) = (min(min_date, max_date), max(min_date, max_date));

    let start = min_date.filter(|d| &span.start < d).unwrap_or(span.start);
    let end = max_date.filter(|d| &span.end > d).unwrap_or(span.end);

    DateTimeSpan { start, end }
}

/// A timeline of events that are used to generate the `ChargePeriods` of the CDR.
struct Timeline {
    /// The list of `Event`s generated from the tariff.
    events: Vec<Event>,

    /// The current is within the \[`min_current`..`max_current`\] range.
    emit_current: bool,

    /// The power is within the \[`min_power`..`max_power`\] range.
    emit_power: bool,
}

/// An event at a time along the timeline.
#[derive(Debug)]
struct Event {
    /// The duration of the Event from the start of the timeline/chargesession.
    duration_from_start: TimeDelta,

    /// The kind of Event.
    kind: EventKind,
}

/// The kind of `Event`.
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
enum EventKind {
    /// The moment a session starts.
    ///
    /// This is added to the list of `Event`s so that the algorithm to generate the `ChargingPeriods`
    /// can iterate over the `Event`s using a window of size 2. The first iteration will always have
    /// `SessionStart` as the first window element and the `Event` of interest as the second.
    SessionStart,

    /// The moment charging ends.
    ///
    /// Charging starts at time 0. When `ChargingEnd`s, parking starts.
    /// This could also be the last `Event` of the chargesession.
    ChargingEnd,

    /// The moment Parking ends
    ///
    /// This could also be the last `Event` of the chargesession.
    /// If a `ParkingEnd` `Event` is present in the `Timeline` then a `ChargingEnd` `Event` will precede it.
    ParkingEnd {
        /// The parking started when `ChargingEnd`ed.
        start: TimeDelta,
    },

    StartTime,

    EndTime,

    /// Minimum duration in seconds the Charging Session MUST last (inclusive).
    ///
    /// When the duration of a Charging Session is longer than the defined value, this `TariffElement` is or becomes active.
    /// Before that moment, this `TariffElement` is not yet active.
    MinDuration,

    /// Maximum duration in seconds the Charging Session MUST last (exclusive).
    ///
    /// When the duration of a Charging Session is shorter than the defined value, this `TariffElement` is or becomes active.
    /// After that moment, this `TariffElement` is no longer active.
    MaxDuration,

    /// Minimum consumed energy in kWh, for example 20, valid from this amount of energy (inclusive) being used.
    MinKwh,

    /// Maximum consumed energy in kWh, for example 50, valid until this amount of energy (exclusive) being used.
    MaxKwh,
}

/// Broad metrics calculated about the chargesession which is given as input for generating a `Timeline` of `Event`s.
#[derive(Debug)]
struct Metrics {
    /// The end date the generated CDR.
    end_date_time: DateTime<Utc>,

    /// The start date the generated CDR.
    start_date_time: DateTime<Utc>,

    /// The time spent charging the battery.
    ///
    /// Charging begins instantly and continues without interruption until the battery is full or the
    /// session time has elapsed.
    duration_charging: TimeDelta,

    /// The time spent parking after charging the battery.
    ///
    /// This duration may be `None` if the battery did not finish charging within the session time.
    duration_parking: Option<TimeDelta>,

    /// The energy that's supplied during the charging period.
    energy_supplied: Kwh,

    /// The maximum DC current that can be delivered to the battery.
    max_current_supply: Ampere,

    /// The maximum DC power(kw) that can be delivered to the battery.
    max_power_supply: Kw,
}

into_caveat!(Metrics);

/// Validate the `Config` and compute various `Metrics` based on the `Config`s fields.
#[expect(
    clippy::needless_pass_by_value,
    reason = "Clippy is complaining that `Config` is not consumed by the function when it clearly is"
)]
fn metrics(elem: &tariff::Versioned<'_>, config: Config) -> Verdict<(Metrics, chrono_tz::Tz)> {
    const SECS_IN_HOUR: Decimal = dec!(3600);

    let warnings = warning::Set::new();

    let Config {
        start_date_time,
        end_date_time,
        max_power_supply_kw,
        max_energy_battery_kwh,
        max_current_supply_amp,
        timezone,
    } = config;
    let duration_session = end_date_time - start_date_time;

    // Std Duration must be positive, if the end time is before the start the conversion will fail.
    if duration_session.num_seconds().is_negative() {
        return warnings.bail(
            WarningKind::StartDateTimeIsAfterEndDateTime,
            elem.as_element(),
        );
    }

    if duration_session.num_seconds() < MIN_CS_DURATION_SECS {
        return warnings.bail(WarningKind::DurationBelowMinimum, elem.as_element());
    }

    // The time needed to charge the battery = battery_capacity(kWh) / power(kw)
    let duration_full_charge_hours = some_dec_or_bail!(
        elem,
        max_energy_battery_kwh.checked_div(max_power_supply_kw),
        warnings,
        "Unable to calculate changing time"
    );

    // The charge duration taking into account that the end of the session can occur before the battery is fully charged.
    let charge_duration_hours =
        Decimal::min(duration_full_charge_hours, duration_session.to_hours_dec());

    let power_supplied_kwh = some_dec_or_bail!(
        elem,
        max_energy_battery_kwh.checked_div(charge_duration_hours),
        warnings,
        "Unable to calculate the power supplied during the charging time"
    );

    // Convert duration from hours to seconds as we work with seconds as the unit of time.
    let charging_duration_secs = some_dec_or_bail!(
        elem,
        charge_duration_hours.checked_mul(SECS_IN_HOUR),
        warnings,
        "Unable to convert charging time from hours to seconds"
    );

    let charging_duration_secs = some_dec_or_bail!(
        elem,
        charging_duration_secs.to_i64(),
        warnings,
        "Unable to convert charging duration Decimal to i64"
    );
    let duration_charging = TimeDelta::seconds(charging_duration_secs);

    let duration_parking = some_dec_or_bail!(
        elem,
        duration_session.checked_sub(&duration_charging),
        warnings,
        "Unable to calculate `idle_duration`"
    );

    let metrics = Metrics {
        end_date_time,
        start_date_time,
        duration_charging,
        duration_parking: Some(duration_parking).filter(|dt| dt.num_seconds().is_positive()),
        energy_supplied: Kwh::from_decimal(power_supplied_kwh),
        max_current_supply: Ampere::from_decimal(max_current_supply_amp),
        max_power_supply: Kw::from_decimal(max_power_supply_kw),
    };

    Ok((metrics, timezone).into_caveat(warnings))
}

fn is_tariff_active(cdr_start: &DateTime<Utc>, tariff: &tariff::v221::Tariff<'_>) -> bool {
    match (tariff.start_date_time, tariff.end_date_time) {
        (None, None) => true,
        (None, Some(end)) => (..end).contains(cdr_start),
        (Some(start), None) => (start..).contains(cdr_start),
        (Some(start), Some(end)) => (start..end).contains(cdr_start),
    }
}

#[derive(Debug)]
pub enum WarningKind {
    /// A Decimal operation failed.
    Decimal(&'static str),

    /// The duration of the chargesession is below the minimum allowed.
    DurationBelowMinimum,

    Price(price::WarningKind),

    /// The `start_date_time` is after the `end_date_time`.
    StartDateTimeIsAfterEndDateTime,

    Tariff(tariff::WarningKind),
}

impl warning::Kind for WarningKind {
    fn id(&self) -> Cow<'static, str> {
        match self {
            Self::Decimal(_) => "decimal_error".into(),
            Self::DurationBelowMinimum => "duration_below_minimum".into(),
            Self::Price(kind) => kind.id(),
            Self::StartDateTimeIsAfterEndDateTime => {
                "start_date_time_is_after_end_date_time".into()
            }
            Self::Tariff(kind) => kind.id(),
        }
    }
}

impl fmt::Display for WarningKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Decimal(msg) => f.write_str(msg),
            Self::DurationBelowMinimum => write!(
                f,
                "The duration of the chargesession is below the minimum: {MIN_CS_DURATION_SECS}"
            ),
            Self::Price(warnings) => {
                write!(f, "Price warnings: {warnings:?}")
            }
            Self::StartDateTimeIsAfterEndDateTime => {
                write!(f, "The `start_date_time` is after the `end_date_time`")
            }
            Self::Tariff(warnings) => {
                write!(f, "Tariff warnings: {warnings:?}")
            }
        }
    }
}

from_warning_all!(
    tariff::WarningKind => WarningKind::Tariff,
    price::WarningKind => WarningKind::Price
);

/// The config for generating a CDR from a tariff.
#[derive(Clone)]
pub struct Config {
    /// The timezone of the EVSE: The timezone where the chargesession took place.
    pub timezone: chrono_tz::Tz,

    /// The start date of the generated CDR.
    pub end_date_time: DateTime<Utc>,

    /// The maximum DC current that can be delivered to the battery.
    pub max_current_supply_amp: Decimal,

    /// The maximum energy(kWh) the vehicle can accept.
    ///
    /// We don't model charging curves for the battery, so we don't care about the existing change of
    /// the battery.
    pub max_energy_battery_kwh: Decimal,

    /// The maximum DC power(kw) that can be delivered to the battery.
    ///
    /// This is modeled as a DC system as we don't care if the delivery medium is DC or one of the
    /// various AC forms. We only care what the effective DC power is. The caller of `cdr_from_tariff`
    /// should convert the delivery medium into a DC kw power by using a power factor.
    ///
    /// In practice the maximum power bottleneck is either the EVSE, the cable or the battery itself.
    /// But whatever the bottleneck is, the caller should work that out and set the maximum expected.
    pub max_power_supply_kw: Decimal,

    /// The start date of the generated CDR.
    pub start_date_time: DateTime<Utc>,
}

#[cfg(test)]
mod test {
    use std::str::FromStr as _;

    use chrono::{DateTime, NaiveDateTime, Utc};

    use super::DateTimeSpan;

    #[track_caller]
    pub(super) fn date_time_span(
        date_start: &str,
        time_start: &str,
        date_end: &str,
        time_end: &str,
    ) -> DateTimeSpan {
        DateTimeSpan {
            start: datetime_utc(date_start, time_start),
            end: datetime_utc(date_end, time_end),
        }
    }

    #[track_caller]
    pub(super) fn datetime_utc(date: &str, time: &str) -> DateTime<Utc> {
        let s = format!("{date} {time}+00:00");
        DateTime::<Utc>::from_str(&s).unwrap()
    }

    #[track_caller]
    pub(super) fn datetime_naive(date: &str, time: &str) -> NaiveDateTime {
        let s = format!("{date}T{time}");
        NaiveDateTime::from_str(&s).unwrap()
    }
}

#[cfg(test)]
mod test_local_to_utc {
    use super::{
        local_to_utc,
        test::{datetime_naive, datetime_utc},
    };

    #[test]
    fn should_convert_from_utc_plus_one() {
        let date_time_utc = local_to_utc(
            chrono_tz::Tz::Europe__Amsterdam,
            datetime_naive("2025-12-18", "11:00:00"),
        )
        .unwrap();

        assert_eq!(date_time_utc, datetime_utc("2025-12-18", "10:00:00"));
    }

    #[test]
    fn should_choose_earliest_date_from_dst_end_fold() {
        // The end of DST in NL.
        let date_time_utc = local_to_utc(
            chrono_tz::Tz::Europe__Amsterdam,
            datetime_naive("2025-10-26", "02:59:59"),
        )
        .unwrap();

        assert_eq!(date_time_utc, datetime_utc("2025-10-26", "00:59:59"));
    }

    #[test]
    fn should_return_none_on_dst_begin_gap() {
        // The beginning of DST in NL.
        let date_time_utc = local_to_utc(
            chrono_tz::Tz::Europe__Amsterdam,
            datetime_naive("2025-03-30", "02:00:00"),
        );

        assert_eq!(date_time_utc, None);
    }
}

#[cfg(test)]
mod test_periods {
    use assert_matches::assert_matches;
    use chrono::TimeDelta;
    use rust_decimal::Decimal;
    use rust_decimal_macros::dec;

    use crate::{
        assert_approx_eq, country, currency,
        duration::ToHoursDecimal as _,
        generate::{self, ChargingPeriod, Dimension, DimensionType, PartialCdr},
        json::FromJson as _,
        price, tariff, Ampere, Kw, Kwh, Money, Price,
    };

    use super::test;

    const DATE: &str = "2025-11-10";

    fn generate_config() -> generate::Config {
        generate::Config {
            timezone: chrono_tz::Europe::Amsterdam,
            start_date_time: test::datetime_utc(DATE, "15:02:12"),
            end_date_time: test::datetime_utc(DATE, "15:12:12"),
            max_power_supply_kw: Decimal::from(24),
            max_energy_battery_kwh: Decimal::from(80),
            max_current_supply_amp: Decimal::from(4),
        }
    }

    #[track_caller]
    fn periods(tariff_json: &str) -> Vec<price::Period> {
        let tariff = tariff::parse(tariff_json).unwrap().unwrap_certain();
        let (metrics, _tz) = generate::metrics(&tariff, generate_config())
            .unwrap()
            .unwrap();
        let tariff = tariff::v221::Tariff::from_json(tariff.as_element())
            .unwrap()
            .unwrap();
        let timeline = super::timeline(chrono_tz::Tz::Europe__Amsterdam, &metrics, &tariff);
        super::charge_periods(&metrics, timeline)
    }

    #[test]
    fn should_generate_periods() {
        const TARIFF_JSON: &str = r#"{
    "country_code": "DE",
    "party_id": "ALL",
    "id": "1",
    "currency": "EUR",
    "type": "REGULAR",
    "elements": [
        {
            "price_components": [{
                  "type": "ENERGY",
                  "price": 0.50,
                  "vat": 20.0,
                  "step_size": 1
            }]
        }
    ],
    "last_updated": "2018-12-05T12:01:09Z"
}
"#;

        let periods = periods(TARIFF_JSON);
        let [period] = periods
            .try_into()
            .expect("There are no restrictions so there should be one big period");

        let price::Period {
            start_date_time,
            consumed,
        } = period;

        assert_eq!(start_date_time, test::datetime_utc(DATE, "15:02:12"));

        let price::Consumed {
            duration_charging,
            duration_parking,
            energy,
            current_max,
            current_min,
            power_max,
            power_min,
        } = consumed;

        assert_eq!(
            duration_charging,
            Some(TimeDelta::minutes(10)),
            "The battery is charged for 10 mins and the plug is pulled"
        );
        assert_eq!(duration_parking, None, "The battery never fully charges");
        assert_approx_eq!(
            energy,
            Some(Kwh::from(4)),
            "The energy supplied is 24 Kwh from a session duration of 10 Mins (0.1666 Hours), so 4 Kwh should be consumed"
        );
        assert_approx_eq!(
            current_max,
            None,
            "There is no `min_current` or `max_current` restriction defined"
        );
        assert_approx_eq!(
            current_min,
            None,
            "There is no `min_current` or `max_current` defined"
        );
        assert_approx_eq!(
            power_max,
            None,
            "There is no `min_power` or `max_power` defined"
        );
        assert_approx_eq!(
            power_min,
            None,
            "There is no `min_power` or `max_power` defined"
        );
    }

    #[test]
    fn should_generate_power() {
        const TARIFF_JSON: &str = r#"{
    "country_code": "DE",
    "party_id": "ALL",
    "id": "1",
    "currency": "EUR",
    "type": "REGULAR",
    "elements": [
        {
            "price_components": [{
              "type": "ENERGY",
              "price": 0.60,
              "vat": 20.0,
              "step_size": 1
            }],
            "restrictions": {
              "max_power": 16.00
            }
        },
        {
            "price_components": [{
              "type": "ENERGY",
              "price": 0.70,
              "vat": 20.0,
              "step_size": 1
            }],
            "restrictions": {
              "max_power": 32.00
            }
        },
        {
            "price_components": [{
                  "type": "ENERGY",
                  "price": 0.50,
                  "vat": 20.0,
                  "step_size": 1
            }]
        }
    ],
    "last_updated": "2018-12-05T12:01:09Z"
}
"#;

        let config = generate_config();
        let tariff_elem = tariff::parse(TARIFF_JSON).unwrap().unwrap_certain();
        let (metrics, _tz) = generate::metrics(&tariff_elem, config.clone())
            .unwrap()
            .unwrap();
        let tariff = tariff::v221::Tariff::from_json(tariff_elem.as_element())
            .unwrap()
            .unwrap();
        let timeline = super::timeline(chrono_tz::Tz::Europe__Amsterdam, &metrics, &tariff);
        let periods = super::charge_periods(&metrics, timeline);

        // let periods = periods(TARIFF_JSON);
        let [ref period] = periods
            .try_into()
            .expect("There are no restrictions so there should be one big period");

        let price::Period {
            start_date_time,
            consumed,
        } = period;

        assert_eq!(*start_date_time, test::datetime_utc(DATE, "15:02:12"));

        let price::Consumed {
            duration_charging,
            duration_parking,
            energy,
            current_max,
            current_min,
            power_max,
            power_min,
        } = consumed;

        assert_eq!(
            *duration_charging,
            Some(TimeDelta::minutes(10)),
            "The battery is charged for 10 mins and the plug is pulled"
        );
        assert_eq!(*duration_parking, None, "The battery never fully charges");
        assert_approx_eq!(
            energy,
            Some(Kwh::from(4)),
            "The energy supplied is 24 Kwh from a session duration of 10 Mins (0.1666 Hours), so 4 Kwh should be consumed"
        );
        assert_approx_eq!(
            current_max,
            None,
            "There is no `min_current` or `max_current` restriction defined"
        );
        assert_approx_eq!(
            current_min,
            None,
            "There is no `min_current` or `max_current` defined"
        );
        assert_approx_eq!(
            power_max,
            Some(Kw::from(24)),
            "There is a `max_power` defined"
        );
        assert_approx_eq!(
            power_min,
            Some(Kw::from(24)),
            "There is a `max_power` defined"
        );
        let report = generate::cdr_from_tariff(&tariff_elem, config).unwrap();
        let (report, warnings) = report.into_parts();
        assert_matches!(warnings.into_kind_vec().as_slice(), []);

        let PartialCdr {
            cpo_country_code,
            party_id,
            start_date_time,
            end_date_time,
            cpo_currency_code,
            total_energy,
            total_charging_duration,
            total_parking_duration,
            total_cost,
            total_energy_cost,
            total_fixed_cost,
            total_parking_duration_cost,
            total_charging_duration_cost,
            charging_periods,
        } = report.partial_cdr;

        assert_eq!(cpo_country_code, Some(country::Code::De));
        assert_eq!(party_id.as_deref(), Some("ALL"));
        assert_eq!(cpo_currency_code, currency::Code::Eur);
        assert_eq!(start_date_time, test::datetime_utc(DATE, "15:02:12"));
        assert_eq!(end_date_time, test::datetime_utc(DATE, "15:12:12"));

        assert_approx_eq!(
            total_cost,
            Some(Price {
                excl_vat: Money::from(2.80),
                incl_vat: Some(Money::from(3.36))
            }),
            "The power input is 24 Kw and the second tariff element with a price per KwH or 0.70 should be used."
        );
        assert_eq!(
            total_charging_duration,
            Some(TimeDelta::minutes(10)),
            "The charging session is 10 min and is stopped before the battery is fully charged."
        );
        assert_eq!(
            total_parking_duration, None,
            "There is no parking time since the battery never fully charged."
        );
        assert_approx_eq!(total_energy, Some(Kwh::from(4)));
        assert_approx_eq!(
            total_energy_cost,
            Some(Price {
                excl_vat: Money::from(2.80),
                incl_vat: Some(Money::from(3.36))
            }),
            "The cost per KwH is 70 cents and the VAT is 20%."
        );
        assert_eq!(total_fixed_cost, None, "There are no fixed costs.");
        assert_eq!(
            total_parking_duration_cost, None,
            "There is no parking cost as there is no parking time."
        );
        assert_eq!(
            total_charging_duration_cost, None,
            "There are no time costs defined in the tariff."
        );

        let [period] = charging_periods
            .try_into()
            .expect("There should be one period.");

        let ChargingPeriod {
            start_date_time,
            dimensions,
            tariff_id,
        } = period;

        assert_eq!(start_date_time, test::datetime_utc(DATE, "15:02:12"));
        assert_eq!(tariff_id.as_deref(), Some("1"));

        let [energy, time] = dimensions
            .try_into()
            .expect("There should be an energy dimension");

        let Dimension {
            dimension_type,
            volume,
        } = energy;

        assert_eq!(dimension_type, DimensionType::Energy);
        assert_approx_eq!(volume, dec!(4.0));

        let Dimension {
            dimension_type,
            volume,
        } = time;

        assert_eq!(dimension_type, DimensionType::Time);
        assert_approx_eq!(volume, TimeDelta::minutes(10).to_hours_dec());
    }

    #[test]
    fn should_generate_current() {
        const TARIFF_JSON: &str = r#"{
    "country_code": "DE",
    "party_id": "ALL",
    "id": "1",
    "currency": "EUR",
    "type": "REGULAR",
    "elements": [
        {
            "price_components": [{
              "type": "ENERGY",
              "price": 0.60,
              "vat": 20.0,
              "step_size": 1
            }],
            "restrictions": {
              "max_current": 2
            }
        },
        {
            "price_components": [{
              "type": "ENERGY",
              "price": 0.70,
              "vat": 20.0,
              "step_size": 1
            }],
            "restrictions": {
              "max_current": 4
            }
        },
        {
            "price_components": [{
                  "type": "ENERGY",
                  "price": 0.50,
                  "vat": 20.0,
                  "step_size": 1
            }]
        }
    ],
    "last_updated": "2018-12-05T12:01:09Z"
}
"#;

        let config = generate_config();
        let tariff_elem = tariff::parse(TARIFF_JSON).unwrap().unwrap_certain();
        let (metrics, _tz) = generate::metrics(&tariff_elem, config.clone())
            .unwrap()
            .unwrap();
        let tariff = tariff::v221::Tariff::from_json(tariff_elem.as_element())
            .unwrap()
            .unwrap();
        let timeline = super::timeline(chrono_tz::Tz::Europe__Amsterdam, &metrics, &tariff);
        let periods = super::charge_periods(&metrics, timeline);

        // let periods = periods(TARIFF_JSON);
        let [ref period] = periods
            .try_into()
            .expect("There are no restrictions so there should be one big period");

        let price::Period {
            start_date_time,
            consumed,
        } = period;

        assert_eq!(*start_date_time, test::datetime_utc(DATE, "15:02:12"));

        let price::Consumed {
            duration_charging,
            duration_parking,
            current_max,
            current_min,
            energy,
            power_max,
            power_min,
        } = consumed;

        assert_eq!(
            *duration_charging,
            Some(TimeDelta::minutes(10)),
            "The battery is charged for 10 mins and the plug is pulled"
        );
        assert_eq!(*duration_parking, None, "The battery never fully charges");
        assert_approx_eq!(
            energy,
            Some(Kwh::from(4)),
            "The energy supplied is 24 Kwh from a session duration of 10 Mins (0.1666 Hours), so 4 Kwh should be consumed"
        );
        assert_approx_eq!(
            current_max,
            Some(Ampere::from(4)),
            "There is a `max_current` restriction defined"
        );
        assert_approx_eq!(
            current_min,
            Some(Ampere::from(4)),
            "There is a `max_current` restriction defined"
        );
        assert_approx_eq!(
            power_max,
            None,
            "There is no `min_power` or `max_power` defined"
        );
        assert_approx_eq!(
            power_min,
            None,
            "There is no `min_power` or `max_power` defined"
        );
        let report = generate::cdr_from_tariff(&tariff_elem, config).unwrap();
        let (report, warnings) = report.into_parts();
        assert_matches!(warnings.into_kind_vec().as_slice(), []);

        let PartialCdr {
            cpo_country_code,
            party_id,
            start_date_time,
            end_date_time,
            cpo_currency_code,
            total_energy,
            total_charging_duration,
            total_parking_duration,
            total_cost,
            total_energy_cost,
            total_fixed_cost,
            total_parking_duration_cost,
            total_charging_duration_cost,
            charging_periods,
        } = report.partial_cdr;

        assert_eq!(cpo_country_code, Some(country::Code::De));
        assert_eq!(party_id.as_deref(), Some("ALL"));
        assert_eq!(cpo_currency_code, currency::Code::Eur);
        assert_eq!(start_date_time, test::datetime_utc(DATE, "15:02:12"));
        assert_eq!(end_date_time, test::datetime_utc(DATE, "15:12:12"));

        assert_approx_eq!(
            total_cost,
            Some(Price {
                excl_vat: Money::from(2.00),
                incl_vat: Some(Money::from(2.40))
            }),
            "The power input is 24 Kw and the second tariff element with a price per KwH or 0.70 should be used."
        );
        assert_eq!(
            total_charging_duration,
            Some(TimeDelta::minutes(10)),
            "The charging session is 10 min and is stopped before the battery is fully charged."
        );
        assert_eq!(
            total_parking_duration, None,
            "There is no parking time since the battery never fully charged."
        );
        assert_approx_eq!(total_energy, Some(Kwh::from(4)));
        assert_approx_eq!(
            total_energy_cost,
            Some(Price {
                excl_vat: Money::from(2.00),
                incl_vat: Some(Money::from(2.40))
            }),
            "The cost per KwH is 70 cents and the VAT is 20%."
        );
        assert_eq!(total_fixed_cost, None, "There are no fixed costs.");
        assert_eq!(
            total_parking_duration_cost, None,
            "There is no parking cost as there is no parking time."
        );
        assert_eq!(
            total_charging_duration_cost, None,
            "There are no time costs defined in the tariff."
        );

        let [period] = charging_periods
            .try_into()
            .expect("There should be one period.");

        let ChargingPeriod {
            start_date_time,
            dimensions,
            tariff_id,
        } = period;

        assert_eq!(start_date_time, test::datetime_utc(DATE, "15:02:12"));
        assert_eq!(tariff_id.as_deref(), Some("1"));

        let [energy, time] = dimensions
            .try_into()
            .expect("There should be an energy dimension");

        let Dimension {
            dimension_type,
            volume,
        } = energy;

        assert_eq!(dimension_type, DimensionType::Energy);
        assert_approx_eq!(volume, dec!(4.0));

        let Dimension {
            dimension_type,
            volume,
        } = time;

        assert_eq!(dimension_type, DimensionType::Time);
        assert_approx_eq!(volume, TimeDelta::minutes(10).to_hours_dec());
    }
}

#[cfg(test)]
mod test_generate {
    use assert_matches::assert_matches;

    use crate::{
        generate::{self},
        tariff,
    };

    use super::test;

    const DATE: &str = "2025-11-10";

    #[test]
    fn should_warn_no_elements() {
        const TARIFF_JSON: &str = r#"{
    "country_code": "DE",
    "party_id": "ALL",
    "id": "1",
    "currency": "EUR",
    "type": "REGULAR",
    "elements": [],
    "last_updated": "2018-12-05T12:01:09Z"
}
"#;

        let tariff = tariff::parse(TARIFF_JSON).unwrap().unwrap_certain();
        let config = generate::Config {
            timezone: chrono_tz::Europe::Amsterdam,
            start_date_time: test::datetime_utc(DATE, "15:02:12"),
            end_date_time: test::datetime_utc(DATE, "15:12:12"),
            max_power_supply_kw: 12.into(),
            max_energy_battery_kwh: 80.into(),
            max_current_supply_amp: 2.into(),
        };
        let warnings = generate::cdr_from_tariff(&tariff, config).unwrap_err();
        let warning = assert_matches!(warnings.as_slice(), [w] => w.kind());
        let warning = assert_matches!(warning, generate::WarningKind::Tariff(w) => w);
        assert_matches!(warning, tariff::WarningKind::NoElements);
    }
}

#[cfg(test)]
mod test_generate_from_single_elem_tariff {
    use assert_matches::assert_matches;
    use chrono::TimeDelta;

    use crate::{
        assert_approx_eq,
        generate::{self, PartialCdr},
        tariff, Kwh, Money, Price,
    };

    use super::test;

    const DATE: &str = "2025-11-10";
    const TARIFF_JSON: &str = r#"{
    "country_code": "DE",
    "party_id": "ALL",
    "id": "1",
    "currency": "EUR",
    "type": "REGULAR",
    "elements": [
        {
            "price_components": [{
                  "type": "ENERGY",
                  "price": 0.50,
                  "vat": 20.0,
                  "step_size": 1
            }]
        }
    ],
    "last_updated": "2018-12-05T12:01:09Z"
}
"#;

    fn generate_config() -> generate::Config {
        generate::Config {
            timezone: chrono_tz::Europe::Amsterdam,
            start_date_time: test::datetime_utc(DATE, "15:02:12"),
            end_date_time: test::datetime_utc(DATE, "15:12:12"),
            max_power_supply_kw: 12.into(),
            max_energy_battery_kwh: 80.into(),
            max_current_supply_amp: 2.into(),
        }
    }

    #[track_caller]
    fn generate(tariff_json: &str) -> generate::Caveat<generate::Report> {
        let tariff = tariff::parse(tariff_json).unwrap().unwrap_certain();
        generate::cdr_from_tariff(&tariff, generate_config()).unwrap()
    }

    #[test]
    fn should_warn_duration_below_min() {
        let tariff = tariff::parse(TARIFF_JSON).unwrap().unwrap_certain();
        let config = generate::Config {
            timezone: chrono_tz::Europe::Amsterdam,
            start_date_time: test::datetime_utc(DATE, "15:02:12"),
            end_date_time: test::datetime_utc(DATE, "15:03:12"),
            max_power_supply_kw: 12.into(),
            max_energy_battery_kwh: 80.into(),
            max_current_supply_amp: 2.into(),
        };
        let warnings = generate::cdr_from_tariff(&tariff, config).unwrap_err();
        let warning = assert_matches!(warnings.as_slice(), [w] => w.kind());
        assert_matches!(warning, generate::WarningKind::DurationBelowMinimum);
    }

    #[test]
    fn should_warn_end_before_start() {
        let tariff = tariff::parse(TARIFF_JSON).unwrap().unwrap_certain();
        let config = generate::Config {
            timezone: chrono_tz::Europe::Amsterdam,
            start_date_time: test::datetime_utc(DATE, "15:12:12"),
            end_date_time: test::datetime_utc(DATE, "15:02:12"),
            max_power_supply_kw: 12.into(),
            max_energy_battery_kwh: 80.into(),
            max_current_supply_amp: 2.into(),
        };
        let warnings = generate::cdr_from_tariff(&tariff, config).unwrap_err();
        let warning = assert_matches!(warnings.as_slice(), [w] => w.kind());
        assert_matches!(
            warning,
            generate::WarningKind::StartDateTimeIsAfterEndDateTime
        );
    }

    #[test]
    fn should_generate_energy_for_ten_minutes() {
        let report = generate(TARIFF_JSON);
        let (report, warnings) = report.into_parts();
        assert_matches!(warnings.into_kind_vec().as_slice(), []);

        let PartialCdr {
            cpo_country_code: _,
            party_id: _,
            start_date_time: _,
            end_date_time: _,
            cpo_currency_code: _,
            total_energy,
            total_charging_duration,
            total_parking_duration,
            total_cost,
            total_energy_cost,
            total_fixed_cost,
            total_parking_duration_cost,
            total_charging_duration_cost,
            charging_periods: _,
        } = report.partial_cdr;

        assert_approx_eq!(
            total_cost,
            Some(Price {
                excl_vat: Money::from(1),
                incl_vat: Some(Money::from(1.2))
            })
        );
        assert_eq!(
            total_charging_duration,
            Some(TimeDelta::minutes(10)),
            "The charging session is 10 min and is stopped before the battery is fully charged."
        );
        assert_eq!(
            total_parking_duration, None,
            "There is no parking time since the battery never fully charged."
        );
        assert_approx_eq!(total_energy, Some(Kwh::from(2)));
        assert_approx_eq!(
            total_energy_cost,
            Some(Price {
                excl_vat: Money::from(1),
                incl_vat: Some(Money::from(1.2))
            }),
            "The cost per KwH is 50 cents and the VAT is 20%."
        );
        assert_eq!(total_fixed_cost, None, "There are no fixed costs.");
        assert_eq!(
            total_parking_duration_cost, None,
            "There is no parking cost as there is no parking time."
        );
        assert_eq!(
            total_charging_duration_cost, None,
            "There are no time costs defined in the tariff."
        );
    }
}

#[cfg(test)]
mod test_clamp_date_time_span {
    use super::{clamp_date_time_span, DateTimeSpan};

    use super::test::{date_time_span, datetime_utc};

    #[test]
    fn should_not_clamp_if_start_and_end_are_none() {
        let in_span = date_time_span("2025-11-01", "12:02:00", "2025-11-10", "14:00:00");

        let out_span = clamp_date_time_span(None, None, in_span.clone());

        assert_eq!(in_span, out_span);
    }

    #[test]
    fn should_not_clamp_if_start_and_end_are_contained() {
        let start = datetime_utc("2025-11-01", "12:02:00");
        let end = datetime_utc("2025-11-10", "14:00:00");
        let in_span = DateTimeSpan { start, end };
        let min_date = datetime_utc("2025-11-01", "11:00:00");
        let max_date = datetime_utc("2025-11-10", "15:00:00");

        let out_span = clamp_date_time_span(Some(min_date), Some(max_date), in_span.clone());

        assert_eq!(in_span, out_span);
    }

    #[test]
    fn should_clamp_if_span_start_earlier() {
        let start = datetime_utc("2025-11-01", "12:02:00");
        let end = datetime_utc("2025-11-10", "14:00:00");
        let in_span = DateTimeSpan { start, end };
        let min_date = datetime_utc("2025-11-02", "00:00:00");
        let max_date = datetime_utc("2025-11-10", "23:00:00");

        let out_span = clamp_date_time_span(Some(min_date), Some(max_date), in_span);

        assert_eq!(out_span.start, min_date);
        assert_eq!(out_span.end, end);
    }

    #[test]
    fn should_clamp_if_end_later() {
        let start = datetime_utc("2025-11-01", "12:02:00");
        let end = datetime_utc("2025-11-10", "14:00:00");
        let in_span = DateTimeSpan { start, end };
        let min_date = datetime_utc("2025-11-01", "00:00:00");
        let max_date = datetime_utc("2025-11-09", "23:00:00");

        let out_span = clamp_date_time_span(Some(min_date), Some(max_date), in_span);

        assert_eq!(out_span.start, start);
        assert_eq!(out_span.end, max_date);
    }
}

#[cfg(test)]
mod test_gen_time_events {
    use assert_matches::assert_matches;
    use chrono::TimeDelta;

    use super::{generate_time_events, v2x::TimeRestrictions};

    use super::test::date_time_span;

    #[test]
    fn should_emit_no_events_before_start_time() {
        // The chargesession takes place before the `start_time`
        let events = generate_time_events(
            chrono_tz::Tz::Europe__Amsterdam,
            date_time_span("2025-11-10", "12:02:00", "2025-11-10", "14:00:00"),
            TimeRestrictions {
                start_time: Some("15:00".parse().unwrap()),
                ..TimeRestrictions::default()
            },
        );

        assert_matches!(events.as_slice(), []);
    }

    #[test]
    fn should_emit_no_events_finishes_at_start_time_pricisely() {
        // The chargesession takes place before the `start_time`
        let events = generate_time_events(
            chrono_tz::Tz::Europe__Amsterdam,
            date_time_span("2025-11-10", "12:02:00", "2025-11-10", "14:00:00"),
            TimeRestrictions {
                start_time: Some("15:00".parse().unwrap()),
                ..TimeRestrictions::default()
            },
        );

        assert_matches!(events.as_slice(), []);
    }

    #[test]
    fn should_emit_one_event_precise_overlap_with_start_time() {
        // The chargesession starts precisely when the `start_time` generates an event.
        let events = generate_time_events(
            chrono_tz::Tz::Europe__Amsterdam,
            date_time_span("2025-11-10", "15:00:00", "2025-11-10", "17:00:00"),
            TimeRestrictions {
                start_time: Some("15:00".parse().unwrap()),
                ..TimeRestrictions::default()
            },
        );

        let [event] = events.try_into().unwrap();
        assert_eq!(event.duration_from_start, TimeDelta::zero());
    }

    #[test]
    fn should_emit_one_event_hour_before_start_time() {
        // The chargesession starts an hour before the `start_time` generates an event.
        let events = generate_time_events(
            chrono_tz::Tz::Europe__Amsterdam,
            date_time_span("2025-11-10", "14:00:00", "2025-11-10", "17:00:00"),
            TimeRestrictions {
                start_time: Some("15:00".parse().unwrap()),
                ..TimeRestrictions::default()
            },
        );

        let [event] = events.try_into().unwrap();
        assert_eq!(event.duration_from_start, TimeDelta::hours(1));
    }

    #[test]
    fn should_emit_one_event_almost_full_day() {
        // The chargesession last from precisely the `start_time` of one day
        // until just before the `start_time` of the next.
        let events = generate_time_events(
            chrono_tz::Tz::Europe__Amsterdam,
            date_time_span("2025-11-10", "15:00:00", "2025-11-11", "14:59:00"),
            TimeRestrictions {
                start_time: Some("15:00".parse().unwrap()),
                ..TimeRestrictions::default()
            },
        );

        let [event] = events.try_into().unwrap();
        assert_eq!(event.duration_from_start, TimeDelta::zero());
    }

    #[test]
    fn should_emit_two_events_full_day_precisely() {
        let events = generate_time_events(
            chrono_tz::Tz::Europe__Amsterdam,
            date_time_span("2025-11-10", "15:00:00", "2025-11-11", "15:00:00"),
            TimeRestrictions {
                start_time: Some("15:00".parse().unwrap()),
                ..TimeRestrictions::default()
            },
        );

        let [event_0, event_1] = events.try_into().unwrap();
        assert_eq!(event_0.duration_from_start, TimeDelta::zero());
        assert_eq!(event_1.duration_from_start, TimeDelta::days(1));
    }

    #[test]
    fn should_emit_two_events_full_day_with_hour_margin() {
        let events = generate_time_events(
            chrono_tz::Tz::Europe__Amsterdam,
            date_time_span("2025-11-10", "14:00:00", "2025-11-11", "16:00:00"),
            TimeRestrictions {
                start_time: Some("15:00".parse().unwrap()),
                ..TimeRestrictions::default()
            },
        );

        let [event_0, event_1] = events.try_into().unwrap();
        assert_eq!(event_0.duration_from_start, TimeDelta::hours(1));
        assert_eq!(
            event_1.duration_from_start,
            TimeDelta::days(1) + TimeDelta::hours(1)
        );
    }
}