use iso_currency::Currency;

use rust_decimal::Decimal;

use time::macros::format_description;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_transaction_date(record))

    fn date(&self, record: Record) -> Date {
        Date::max(record.booking_date, record.value_date)

        record: &csv::Record,

        record: Record,

        let date = parse_transaction_date(record)?;
        let commodity = Commodity::try_from(&record[12]).map_err(|_err| -> Error { todo!() })?;

        let commodity =
            Commodity::try_from(record.currency.code()).expect("currencies are valid commodities");

            let mut transaction = Transaction::on(date);

            let mut transaction = Transaction::on(record.value_date);

            transaction.set_payee(&record[6]).set_narration(&record[10]);

            transaction
                .set_payee(record.transaction_partner_name)
                .set_narration(record.purpose);

            let amount = {
                let amount = &record[11];
                let amount = german_decimal::parse(amount).map_err(|_| -> Error { todo!() })?;
                Amount::new(amount, commodity)
            };
            let opposite_iban = &record[7];

                .get(opposite_iban)

                .get(record.transaction_partner_iban)

                    opposite_iban,

                    record.transaction_partner_iban,

                    posting.set_amount(amount);

                    posting.set_amount(Amount::new(record.amount, commodity));

        let balance = {
            let amount = {
                let amount = &record[13];
                let amount = german_decimal::parse(amount).map_err(|_| -> Error { todo!() })?;
                Amount::new(amount, commodity)
            };

            Balance::new(date.next_day().unwrap(), self.config.account.base(), amount)
        };

        let balance = Balance::new(
            record.value_date.next_day().unwrap(),
            self.config.account.base(),
            Amount::new(record.balance, commodity),
        );

#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Betrag", with = "german_decimal::serde")]
    amount: Decimal,
    #[serde(rename = "Saldo nach Buchung", with = "german_decimal::serde")]
    balance: Decimal,

    #[serde(rename = "Buchungstag", with = "dmy")]
    booking_date: Date,
    #[serde(rename = "Waehrung")]
    currency: Currency,
    #[serde(rename = "Verwendungszweck")]
    purpose: &'r str,
    #[serde(rename = "IBAN Zahlungsbeteiligter")]
    transaction_partner_iban: &'r str,
    #[serde(rename = "Name Zahlungsbeteiligter")]
    transaction_partner_name: &'r str,
    #[serde(rename = "Valutadatum", with = "dmy")]
    value_date: Date,
}

fn parse_transaction_date(record: &csv::Record) -> Result<Date, Error> {
    use time::format_description::FormatItem;
    const DATE_COLUMN_INDEX: usize = 5;
    const DATE_FORMAT: &[FormatItem] = format_description!("[day].[month].[year]");

    Date::parse(&record[DATE_COLUMN_INDEX], DATE_FORMAT).map_err(|_| todo!())
}

time::serde::format_description!(dmy, Date, "[day].[month].[year]");

iso_currency.workspace   = true

rust_decimal.workspace   = true

use rust_decimal::Decimal;

use time::format_description::well_known::Iso8601;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_order_date(record))

    fn date(&self, record: Record) -> Date {
        record.date

        record: &csv::Record,

        record: Record,

        const DEPOT_ID_COLUMN_INDEX: usize = 1;
        const PRICE_COLUMN_INDEX: usize = 5;
        const TOTAL_COLUMN_INDEX: usize = 7;
        const TRANSACTION_KIND_COLUMN_INDEX: usize = 3;
        const UNIT_COLUMN_INDEX: usize = 8;
        const UNITS_COLUMN_INDEX: usize = 6;
        let context = TemplateContext::try_from(&record[DEPOT_ID_COLUMN_INDEX])?;

        let context = TemplateContext::try_from(record.depot_id)?;

        let stock = self.lookup_commodity(context.position).unwrap();

        let stock = self.lookup_commodity(record.depot_id.position).unwrap();

        let date = parse_order_date(record)?;

        let date = record.date;

        let currency: Commodity = self.lookup_currency(&record[UNIT_COLUMN_INDEX])?;
        let units = {
            let value: &str = &record[UNITS_COLUMN_INDEX];
            german_decimal::parse(value).map_err(|_| todo!())
        }?;
        let unit_cost = {
            let price = &record[PRICE_COLUMN_INDEX];
            german_decimal::parse(price).map_err(|_| todo!())
        }?;

        let currency: Commodity = self.lookup_currency(record.currency)?;
        let units = record.shares;
        let unit_cost = record.unit_cost;

        let total = {
            let value: &str = &record[TOTAL_COLUMN_INDEX];
            german_decimal::parse(value).map_err(|_| todo!())
        }?;
        let total = Amount {
            amount: total,
            commodity: currency,
        };

        let total = Amount::new(record.total, currency);

        let transaction_kind = TransactionKind::from_str(&record[TRANSACTION_KIND_COLUMN_INDEX])?;

        let transaction_kind = record.transaction_kind;

    }
}
#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "DATUM")]
    date: Date,
    #[serde(rename = "UNIONDEPOTNUMMER")]
    depot_id: DepotId<'r>,
    #[serde(rename = "TRANSAKTIONSART")]
    transaction_kind: TransactionKind,
    #[serde(rename = "FONDSPREIS", with = "german_decimal::serde")]
    unit_cost: Decimal,
    #[serde(rename = "ANTEILE", with = "german_decimal::serde")]
    shares: Decimal,
    #[serde(rename = "VOLUMEN", with = "german_decimal::serde")]
    total: Decimal,
    #[serde(rename = "EINHEIT")]
    currency: &'r str,
}
#[derive(Clone, Copy, Debug, Deserialize)]
#[serde(try_from = "&str")]
struct DepotId<'r> {
    depot: &'r str,
    position: &'r str,
}
impl<'i> TryFrom<&'i str> for DepotId<'i> {
    type Error = Error;
    fn try_from(value: &'i str) -> Result<Self, Self::Error> {
        let (depot, position) = value.split_once('/').ok_or_else(|| todo!())?;
        Ok(Self { depot, position })

impl<'i> TryFrom<&'i str> for TemplateContext<'i> {

impl<'r> TryFrom<DepotId<'r>> for TemplateContext<'r> {

    fn try_from(value: &'i str) -> Result<Self, Self::Error> {
        let (depot, position) = value.split_once('/').ok_or_else(|| todo!())?;

    fn try_from(value: DepotId<'r>) -> Result<Self, Self::Error> {
        let DepotId { depot, position } = value;

#[derive(Clone, Copy, Debug)]

#[derive(Clone, Copy, Debug, Deserialize)]

    #[serde(rename = "Verkauf wg. Depotgebühr UID mit Postbox")]

    #[serde(rename = "Ertragsausschüttung")]

    #[serde(rename = "Fremde Gebühren")]

    #[serde(rename = "Kauf")]

    #[serde(rename = "Storno wegen Rücklastschrift")]

    #[serde(rename = "Verkauf")]

fn parse_order_date(record: &csv::Record) -> Result<Date, Error> {
    const ORDER_DATE_COLUMN_INDEX: usize = 0;
    Date::parse(&record[ORDER_DATE_COLUMN_INDEX], &Iso8601::PARSING).map_err(|_| todo!())
}

rust_decimal.workspace   = true

use csv::Record;

use rust_decimal::Decimal;

use time::macros::format_description;

    fn extract_record(&self, record: &Record) -> Result<(Transaction, Balance), Error> {
        let date = parse_date(record).unwrap();
        let time =
            Time::parse(&record[1], format_description!("[hour]:[minute]:[second]")).unwrap();
        let tz = time_tz::timezones::get_by_name(&record[2]).unwrap();

    fn extract_record(&self, record: Record) -> Result<(Transaction, Balance), Error> {
        dbg!(record);

        let timestamp = date.with_time(time).assume_timezone(tz).unwrap();
        let commodity = Commodity::try_from(&record[4]).unwrap();

        let tz = time_tz::timezones::get_by_name(record.timezone).unwrap();
        let timestamp = record
            .date
            .with_time(record.time)
            .assume_timezone(tz)
            .unwrap();

            let currency: &str = &commodity;

            let currency: &str = &record.currency;

            let mut transaction = Transaction::on(date);

            let mut transaction = Transaction::on(record.date);

            let kind = TransactionKind::try_from(&record[3])?;
            let (payee, opposite_account) = match kind {

            let (payee, opposite_account) = match record.description {

                        .get(&record[10])

                        .get(record.sender_email)

                    self.config.reference_accounts[&record[13]].clone(),

                    self.config.reference_accounts[record.bank_account].clone(),

                    non_empty_field(&record[11]),

                    non_empty_field(record.name),

                        .get(&record[10])

                        .get(record.sender_email)

            let transaction_id = &record[9];
            if matches!(kind, TransactionKind::Deposit) {
                transaction.add_link(Link::try_from(format!("^paypal.{transaction_id}")).unwrap());

            if matches!(record.description, TransactionKind::Deposit) {
                transaction.add_link(
                    Link::try_from(format!("^paypal.{}", record.transaction_id)).unwrap(),
                );

                .add_meta(common_keys::TRANSACTION_ID, transaction_id);

                .add_meta(common_keys::TRANSACTION_ID, record.transaction_id);

            if let Some(invoice_id) = non_empty_field(&record[16]) {

            if let Some(invoice_id) = record.invoice_id {

            if let Some(related_transaction_id) = non_empty_field(&record[17]) {

            if let Some(related_transaction_id) = record.related_transaction_id {

            let amount = Amount::new(german_decimal::parse(&record[5]).unwrap(), commodity);

            let amount = Amount::new(record.gross, record.currency);

            let date = record.date.next_day().unwrap();

            let amount = german_decimal::parse(&record[8]).unwrap();
            let amount = Amount::new(amount, commodity);

            let amount = Amount::new(record.balance, record.currency);

            let date = date.next_day().unwrap();

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_date(record))

    fn date(&self, record: Record) -> Date {
        record.date

        record: &csv::Record,

        record: Record,

}
#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Datum", with = "dmy")]
    date: Date,
    #[serde(rename = "Uhrzeit", with = "hms")]
    time: Time,
    #[serde(rename = "Zeitzone")]
    timezone: &'r str,
    #[serde(rename = "Beschreibung")]
    description: TransactionKind,
    #[serde(rename = "Währung")]
    currency: Commodity,
    #[serde(rename = "Brutto", with = "german_decimal::serde")]
    gross: Decimal,
    #[serde(rename = "Guthaben", with = "german_decimal::serde")]
    balance: Decimal,
    #[serde(rename = "Transaktionscode")]
    transaction_id: &'r str,
    #[serde(rename = "Absender E-Mail-Adresse")]
    sender_email: &'r str,
    #[serde(rename = "Name")]
    name: &'r str,
    #[serde(rename = "Bankkonto")]
    bank_account: &'r str,
    #[serde(rename = "Rechnungsnummer")]
    invoice_id: Option<&'r str>,
    #[serde(borrow, rename = "Zugehöriger Transaktionscode")]
    related_transaction_id: Option<&'r str>,

#[derive(Clone, Copy, Debug, Eq, PartialEq)]

#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]

    #[serde(rename = "Rückbuchung")]

    #[serde(rename = "Allgemeine Währungsumrechnung")]

    #[serde(
        alias = "Allgemeine Abbuchung – Bankkonto",
        rename = "Bankgutschrift auf PayPal-Konto"
    )]

    #[serde(
        alias = "Allgemeine Zahlung",
        alias = "Handyzahlung",
        alias = "PayPal Express-Zahlung",
        alias = "Rückzahlung",
        alias = "Spendenzahlung",
        alias = "Website-Zahlung",
        rename = "Zahlung im Einzugsverfahren mit Zahlungsrechnung"
    )]

fn parse_date(record: &Record) -> Result<Date, Error> {
    use time::format_description::FormatItem;
    const DATE_COLUMN_INDEX: usize = 0;
    const DATE_FORMAT: &[FormatItem] = format_description!("[day].[month].[year]");
    Date::parse(&record[DATE_COLUMN_INDEX], DATE_FORMAT).map_err(|_| todo!())
}

time::serde::format_description!(dmy, Date, "[day].[month].[year]");
time::serde::format_description!(hms, Time, "[hour]:[minute]:[second]");

use time::macros::format_description;

        record: &csv::Record,

        record: Record,

        let (payee, iban) = record[2]

        let (payee, iban) = record
            .description

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_transaction_date(record))

    fn date(&self, record: Record) -> Date {
        record.date

        record: &csv::Record,

        record: Record,

        let date = parse_transaction_date(record)?;
        let commodity = self.config.commodity;

        let date = record.date;

        let transaction_kind = TransactionKind::try_from(&record[1])?;

        let transaction_kind = record.transaction_kind;

        let amount = {
            let amount = &record[3];
            let amount = german_decimal::parse(amount).map_err(|_| -> Error { todo!() })?;
            Amount::new(amount, commodity)
        };

        let amount = Amount::new(record.amount, self.config.commodity);

#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Datum", with = "dmy")]
    date: Date,
    #[serde(rename = "Beschreibung")]
    transaction_kind: TransactionKind<'r>,
    #[serde(rename = "Beschreibung2")]
    description: &'r str,
    #[serde(rename = "Wert", with = "german_decimal::serde")]
    amount: Decimal,
}

#[derive(Clone, Copy, Debug)]

#[derive(Clone, Copy, Debug, Deserialize)]
#[serde(try_from = "&str")]

fn parse_transaction_date(record: &csv::Record) -> Result<Date, Error> {
    use time::format_description::FormatItem;
    const DATE_COLUMN_INDEX: usize = 0;
    const DATE_FORMAT: &[FormatItem] = format_description!("[day].[month].[year]");
    Date::parse(&record[DATE_COLUMN_INDEX], DATE_FORMAT).map_err(|_| todo!())
}

time::serde::format_description!(dmy, Date, "[day].[month].[year]");

use core::fmt::Write;

use csv::Record;

use tap::Tap as _;
use tap::TapFallible;

use time::parsing::Parsed;

mod dmy_short {
    pub fn deserialize<'de, D>(deserializer: D) -> Result<time::Date, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct Visitor;
        impl serde::de::Visitor<'_> for Visitor {
            type Value = time::Date;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("a date in dd.mm.yy format")
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                const BASE_YEAR: i32 = 2000;
                const DATE_FORMAT: &[time::format_description::FormatItem] =
                    time::macros::format_description!("[day].[month].[year repr:last_two]");
                let mut parsed = time::parsing::Parsed::new();
                parsed.parse_items(v.as_bytes(), DATE_FORMAT).unwrap();
                let year_last_two = i32::from(parsed.year_last_two().unwrap());
                parsed.set_year(BASE_YEAR + year_last_two);
                parsed.try_into().map_err(E::custom)
            }
        }

        deserializer.deserialize_str(Visitor)
    }
}

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_transaction_date(record))

    fn date(&self, record: Record) -> Date {
        record.booking_date

        record: &Record,

        record: Record,

        const DEPOT_ID_COLUMN_INDEX: usize = 0;
        const DEPOT_POSITION_COLUMN_INDEX: usize = 1;
        const FUND_CURRENCY_COLUMN_INDEX: usize = 12;
        const FUND_NAME_COLUMN_INDEX: usize = 6;
        const ISIN_COLUMN_INDEX: usize = 7;
        const REFERENCE_COLUMN_INDEX: usize = 2;
        const SHARES_COLUMN_INDEX: usize = 10;
        const PRICE_DATE_COLUMN_INDEX: usize = 13;
        const PAYMENT_AMOUNT_COLUMN_INDEX: usize = 8;
        const PAYMENT_CURRENY_COLUMN_INDEX: usize = 9;
        const TRANSACTION_KIND_COLUMN_INDEX: usize = 4;
        const SHARE_PRICE_COLUMN_INDEX: usize = 11;
        const EXCHANGE_RATE_COLUMN_INDEX: usize = 14;

        let kind = TransactionKind::try_from(&record[TRANSACTION_KIND_COLUMN_INDEX])?;
        let transaction_id = &record[REFERENCE_COLUMN_INDEX];
        let (reference, ..) = transaction_id.split_once('/').unwrap();

        let reference = record.reference.transaction_id;

        let fund_commodity = Commodity::try_from(&record[ISIN_COLUMN_INDEX]).unwrap();
        let depot_id = &record[DEPOT_ID_COLUMN_INDEX];
        let position = &record[DEPOT_POSITION_COLUMN_INDEX];

        let depot_id = record.depot_id;
        let position = record.depot_position;

        };
        let fund_currency = Commodity::try_from(&record[FUND_CURRENCY_COLUMN_INDEX]).unwrap();
        let share_price = Amount::new(
            german_decimal::parse(&record[SHARE_PRICE_COLUMN_INDEX]).unwrap(),
            fund_currency,
        );
        let shares_amount = Amount::new(
            german_decimal::parse(&record[SHARES_COLUMN_INDEX])
                .map_err(|_| -> Error { todo!() })?,
            fund_commodity,
        );
        let payment_currency = Commodity::try_from(&record[PAYMENT_CURRENY_COLUMN_INDEX])
            .map_err(|_| -> Error { todo!() })?;
        let payment_amount = {
            let amount = parse_decimal_with_precision(&record[PAYMENT_AMOUNT_COLUMN_INDEX], 2)
                .map_err(|_| -> Error { todo!() })?;
            Amount::new(amount, payment_currency)

        let investment_amount_payment = {
            let investment_amount = &record[15];
            let investment_amount = parse_decimal_with_precision(investment_amount, 2)
                .map_err(|_| -> Error { todo!() })?;

        let fund_currency = record.fund_currency;
        let share_price = Amount::new(record.share_price, fund_currency);

            Amount::new(investment_amount, payment_currency)
        };

        let shares_amount = Amount::new(record.shares, record.isin);

        let investment_amount_fund = {
            let exchange_rate = Some(&record[EXCHANGE_RATE_COLUMN_INDEX])
                .filter(|value| !value.is_empty())
                .map(german_decimal::parse)
                .transpose()
                .map_err(|_| -> Error { todo!() })?;

        let payment_amount = Amount::new(record.payment_amount, record.payment_curreny);

            exchange_rate.map(|rate| {
                let mut amount = investment_amount_payment.amount * rate;
                amount.rescale(2);
                Amount::new(amount, fund_currency)
            })
        };

        let investment_amount_payment =
            Amount::new(record.investment_amount, record.payment_curreny);

        let fees = german_decimal::parse(&record[26])
            .unwrap()
            .tap_mut(|amount| {
                amount.rescale(2);
            });

        let investment_amount_fund = record.exchange_rate.map(|rate| {
            let mut amount = investment_amount_payment.amount * rate;
            amount.rescale(2);
            Amount::new(amount, fund_currency)
        });

        let mut transaction = Transaction::on(parse_transaction_date(record)?);

        let mut transaction = Transaction::on(record.booking_date);

            .set_narration(kind.format_narration(&record[FUND_NAME_COLUMN_INDEX]))
            .add_meta(common_keys::TRANSACTION_ID, transaction_id);

            .set_narration(record.transaction_kind.format_narration(record.fund_name))
            .add_meta(common_keys::TRANSACTION_ID, record.reference.to_string());

        match kind {

        match record.transaction_kind {

                if !fees.is_zero() {
                    let fees = Amount::new(fees, payment_currency);

                if !record.fees.is_zero() {
                    let fees = Amount::new(record.fees, record.payment_curreny);

                                        let currency: &str = &payment_currency;

                                        let currency: &str = &record.payment_curreny;

                            posting.set_amount(Amount::new(fees, payment_currency));

                            posting.set_amount(Amount::new(record.fees, record.payment_curreny));

                if !fees.is_zero() {
                    let fees = Amount::new(fees, payment_currency);

                if !record.fees.is_zero() {
                    let fees = Amount::new(record.fees, record.payment_curreny);

                        if payment_currency != fund_currency {

                        if record.payment_curreny != fund_currency {

                            let exchange_rate = german_decimal::parse(&record[14]).unwrap();

                            let exchange_rate = record
                                .exchange_rate
                                .expect("exchange rate is set when currencies differ");

                if !fees.is_zero() {
                    let fees = Amount::new(fees, payment_currency);

                if !record.fees.is_zero() {
                    let fees = Amount::new(record.fees, record.payment_curreny);

                        if payment_currency != fund_currency {

                        if record.payment_curreny != fund_currency {

                            let exchange_rate = german_decimal::parse(&record[14]).unwrap();

                            let exchange_rate = record
                                .exchange_rate
                                .expect("exchange rate is set when currencies differ");

                if !fees.is_zero() {
                    let fees = Amount::new(fees, payment_currency);

                if !record.fees.is_zero() {
                    let fees = Amount::new(record.fees, record.payment_curreny);

                                        let currency: &str = &payment_currency;

                                        let currency: &str = &record.payment_curreny;

            let date = parse_date(&record[PRICE_DATE_COLUMN_INDEX])?;
            Price::new(date, fund_commodity, share_price)

            let date = record.price_date;
            Price::new(date, record.isin, share_price)

#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Buchungsdatum", with = "dmy_short")]
    booking_date: Date,
    #[serde(rename = "Depotnummer")]
    depot_id: &'r str,
    #[serde(rename = "Depotposition")]
    depot_position: &'r str,
    #[serde(rename = "Devisenkurs  (ZW/FW)", with = "german_decimal::serde::opt")]
    exchange_rate: Option<Decimal>,
    #[serde(
        rename = "Entgelt in ZW",
        with = "german_decimal::serde::with_precision::<2>"
    )]
    fees: Decimal,

    #[serde(rename = "Fondswährung (FW)")]
    fund_currency: Commodity,
    #[serde(rename = "Fonds")]
    fund_name: &'r str,
    #[serde(
        rename = "Anlagebetrag in ZW",
        with = "german_decimal::serde::with_precision::<2>"
    )]
    investment_amount: Decimal,
    #[serde(rename = "ISIN")]
    isin: Commodity,
    #[serde(
        rename = "Zahlungsbetrag in ZW",
        with = "german_decimal::serde::with_precision::<2>"
    )]
    payment_amount: Decimal,
    #[serde(rename = "Zahlungswährung (ZW)")]
    payment_curreny: Commodity,
    #[serde(rename = "Kursdatum", with = "dmy_short")]
    price_date: Date,
    #[serde(rename = "Ref. Nr.")]
    reference: TransactionReference<'r>,
    #[serde(rename = "Abrechnungskurs in FW", with = "german_decimal::serde")]
    share_price: Decimal,
    #[serde(rename = "Anteile", with = "german_decimal::serde")]
    shares: Decimal,
    #[serde(rename = "Umsatzart")]
    transaction_kind: TransactionKind,
}

#[derive(Debug)]

#[derive(Clone, Copy, Debug, Deserialize)]

    #[serde(rename = "Entgeltbelastung Verkauf")]

    #[serde(rename = "Kauf")]

    #[serde(rename = "Wiederanlage Fondsertrag")]

    #[serde(rename = "Ansparplan")]

    #[serde(rename = "Neuabrechnung Ansparplan")]

    #[serde(rename = "Stornierung Ansparplan")]

pub fn parse_transaction_date(record: &Record) -> Result<Date, Error> {
    const TRANSACTION_DATE_COLUMN_INDEX: usize = 3;
    parse_date(&record[TRANSACTION_DATE_COLUMN_INDEX])

#[derive(Clone, Copy, Debug)]
struct TransactionReference<'r> {
    order_date: Date,
    transaction_id: &'r str,

pub fn parse_date(date: &str) -> Result<Date, Error> {
    const BASE_YEAR: i32 = 2000;
    const DATE_FORMAT: &[time::format_description::FormatItem] =
        format_description!("[day].[month].[year repr:last_two]");

impl<'de, 'r> serde::Deserialize<'de> for TransactionReference<'r>
where
    'de: 'r,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = TransactionReference<'de>;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("an ebase transaction reference number")
            }
            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                let (transaction_id, order_date) = v
                    .split_once('/')
                    .ok_or(E::custom("unexpected format for transaction reference"))?;

    let mut parsed = Parsed::new();
    parsed.parse_items(date.as_bytes(), DATE_FORMAT).unwrap();

                let order_date = Date::parse(
                    order_date,
                    time::macros::format_description!("[day][month][year]"),
                )
                .map_err(E::custom)?;

    let year_last_two = i32::from(parsed.year_last_two().unwrap());
    parsed.set_year(BASE_YEAR + year_last_two);

                Ok(TransactionReference {
                    order_date,
                    transaction_id,
                })
            }
        }

    parsed.try_into().map_err(Error::from)

        deserializer.deserialize_str(Visitor)
    }

fn parse_decimal_with_precision(
    decimal: &str,
    precision: u32,
) -> Result<Decimal, rust_decimal::Error> {
    german_decimal::parse(decimal).tap_ok_mut(|amount| {
        amount.rescale(precision);
    })

impl std::fmt::Display for TransactionReference<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut buffer: &mut [u8] = &mut [0u8; 8];
        f.write_str(self.transaction_id)?;
        f.write_char('/')?;
        self.order_date
            .format_into(&mut buffer, format_description!("[day][month][year]"))
            .expect("valid formatting");
        f.write_str(core::str::from_utf8(buffer).expect("valid UTF-8"))
    }

use csv::Record;

use rust_decimal::Decimal;

use snafu::ResultExt as _;

use time::macros::format_description;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_price_date(record))

    fn date(&self, record: Record) -> Date {
        record.share_price_date

        record: &Record,

        record: Record,

        const CURRENCY_COLUMN_INDEX: usize = 7;
        const DEPOT_ID_COLUMN_INDEX: usize = 0;
        const DEPOT_POSITION_COLUMN_INDEX: usize = 1;
        const ISIN_COLUMN_INDEX: usize = 3;
        const SHARE_PRICE_COLUMN_INDEX: usize = 6;
        const SHARES_COLUMN_INDEX: usize = 5;
        let date = parse_price_date(record)?;
        let depot_id = &record[DEPOT_ID_COLUMN_INDEX];
        let position = {
            let position = &record[DEPOT_POSITION_COLUMN_INDEX];
            let position = usize::from_str(position).context(PositionSnafu { position })?;
            format!("{:02}", position)
        };

        let position = format!("{:02}", record.depot_position);

            depot_id: <&Seg>::try_from(depot_id).unwrap(),

            depot_id: <&Seg>::try_from(record.depot_id).unwrap(),

        let isin = {
            let isin = &record[ISIN_COLUMN_INDEX];

        let isin = record.isin;
        let total_shares = Amount::new(record.shares, isin);

            Commodity::try_from(isin).context(IsinSnafu { isin })?
        };
        let total_shares = {
            let shares = &record[SHARES_COLUMN_INDEX];
            let shares = german_decimal::parse(shares).context(SharesSnafu { shares })?;
            Amount::new(shares, isin)
        };

            date,

            record.share_price_date,

        let share_price = {
            let share_price = &record[SHARE_PRICE_COLUMN_INDEX];
            let amount =
                german_decimal::parse(share_price).context(SharePriceSnafu { share_price })?;
            let currency = &record[CURRENCY_COLUMN_INDEX];
            let commodity = Commodity::try_from(currency).context(CurrencySnafu { currency })?;

        let share_price = Amount::new(record.share_price, record.share_price_currency);
        let price = Price::new(record.share_price_date, isin, share_price);

            Amount::new(amount, commodity)
        };
        let price = Price::new(date, isin, share_price);

#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Depotnummer")]
    depot_id: &'r str,
    #[serde(rename = "Position")]
    depot_position: usize,
    #[serde(rename = "ISIN")]
    isin: Commodity,
    #[serde(rename = "Anteile", with = "german_decimal::serde")]
    shares: Decimal,
    #[serde(rename = "Anteilswert", with = "german_decimal::serde")]
    share_price: Decimal,
    #[serde(rename = "Währung (Anteilswert)")]
    share_price_currency: Commodity,
    #[serde(rename = "Kursdatum", with = "dmy")]
    share_price_date: Date,
}

}
pub fn parse_price_date(record: &Record) -> Result<Date, Error> {
    const PRICE_DATE_COLUMN_INDEX: usize = 8;
    parse_date(&record[PRICE_DATE_COLUMN_INDEX])

pub fn parse_date(date: &str) -> Result<Date, Error> {
    use time::format_description::FormatItem;
    const DATE_FORMAT: &[FormatItem] = format_description!("[day].[month].[year]");

    Date::parse(date, DATE_FORMAT)
        .map_err(time::Error::from)
        .context(DateFormatSnafu {})
}

time::serde::format_description!(dmy, Date, "[day].[month].[year]");

use serde::Deserialize;

use tap::TapFallible;

    #[snafu(display("error(s) while extracting data from records"))]
    Extracting {

    #[snafu(display("error(s) while processing CSV records"))]
    Processing {

    #[snafu(display("error while parsing CSV record"))]

    #[snafu(display("error while parsing CSV file"))]

        self.fold(
            file,
            None,
            |record| inner.date(record).transpose(),
            |date, extracted| {
                if let Some(new_date) = extracted {
                    let date = date.get_or_insert(new_date);
                    *date = Date::max(*date, new_date);
                };
            },
        )

        (|| {
            let mut date = None;
            let data = std::fs::read_to_string(file).context(ReadingSnafu { file })?;
            let mut reader = self.builder.from_reader(data.as_bytes());
            let headers = reader.headers().context(ParsingSnafu {})?.clone();
            let mut errors = Vec::new();
            let mut record = Record::new();
            while reader.read_record(&mut record).context(ParsingSnafu {})? {
                let position = record.position().expect("position is set by csv::Reader");
                let offset = SourceOffset::from((position.byte() + 1) as usize);
                let new_date = record
                    .deserialize(Some(&headers))
                    .map(|record| inner.date(record))
                    .context(DeserializationSnafu { offset });
                match new_date {
                    Ok(new_date) if errors.is_empty() => {
                        let date = date.get_or_insert(new_date);
                        *date = Date::max(*date, new_date);
                    }
                    // we can skip updating our state when we already have at least one error
                    Ok(_) => {}
                    Err(error) => {
                        errors.push(error);
                    }
                }
            }
            if errors.is_empty() {
                Ok(date)
            } else {
                ProcessingSnafu { errors, data }.fail()
            }
        })()

        self.fold(
            file,
            Vec::new(),
            |record| {
                let position = record.position().expect("position is set by csv::Reader");
                inner.extract(existing, record).tap_ok_mut(|records| {
                    records.iter_mut().for_each(|directive| {
                        directive.add_meta(common_keys::IMPORTED_RECORD, position.record());
                    });
                })
            },
            |directives, extracted| {
                directives.extend(extracted);
            },
        )
    }
    pub fn identify(&self, file: &Utf8Path, expected_headers: &[&str]) -> Result<bool, csv::Error> {
        if !matches!(file.extension(), Some(ext) if ext.eq_ignore_ascii_case("csv")) {
            return Ok(false);
        }
        let mut reader = self.builder.from_path(file)?;
        let headers = reader.headers()?;
        Ok(headers == expected_headers)
    }
}
impl Importer {
    fn fold<State, Err>(
        &self,
        file: &Utf8Path,
        mut state: State,
        extractor: impl Fn(&Record) -> Result<State, Err>,
        folder: impl Fn(&mut State, State),
    ) -> Result<State, Error<Err>>
    where
        Err: Diagnostic + Send + Sync,
    {

        let mut directives = Vec::new();

        let headers = reader.headers().context(ParsingSnafu {})?.clone();

        {
            let mut record = Record::new();
            while reader.read_record(&mut record).context(ParsingSnafu {})? {
                let position = record.position().expect("position is set by csv::Reader");
                let offset = SourceOffset::from((position.byte() + 1) as usize);

        let mut record = Record::new();
        while reader.read_record(&mut record).context(ParsingSnafu {})? {
            let position = record.position().expect("position is set by csv::Reader");
            let offset = SourceOffset::from((position.byte() + 1) as usize);

                match extractor(&record).context(RecordSnafu { offset }) {
                    Ok(new_state) if errors.is_empty() => {
                        folder(&mut state, new_state);
                    }

            let extracted = record
                .deserialize(Some(&headers))
                .context(DeserializationSnafu { offset })
                .and_then(|record| {
                    inner
                        .extract(existing, record)
                        .context(ExtractionSnafu { offset })
                });
            match extracted {
                Ok(extracted) if errors.is_empty() => {
                    directives.extend(extracted.into_iter().map(|mut directive| {
                        directive.add_meta(common_keys::IMPORTED_RECORD, position.record());
                        directive
                    }));
                }

                    // we can skip updating our state when we already have at least one error
                    Ok(_) => {}

                // we can skip updating our state when we already have at least one error
                Ok(_) => {}

                    Err(error) => {
                        errors.push(error);
                    }

                Err(error) => {
                    errors.push(error);

            Ok(state)

            Ok(directives)

            ExtractingSnafu { errors, data }.fail()

            ProcessingSnafu { errors, data }.fail()
        }
    }
    pub fn identify(&self, file: &Utf8Path, expected_headers: &[&str]) -> Result<bool, csv::Error> {
        if !matches!(file.extension(), Some(ext) if ext.eq_ignore_ascii_case("csv")) {
            return Ok(false);

        let mut reader = self.builder.from_path(file)?;
        let headers = reader.headers()?;
        Ok(headers == expected_headers)

impl Importer {}

#[snafu(display("encountered error while extracting record"))]
pub struct RecordError<E>

pub enum RecordError<E>

    #[diagnostic_source]
    source: E,

    #[snafu(display("error while deserializing CSV record"))]
    Deserialization {
        source: csv::Error,
        #[label("in this record")]
        offset: SourceSpan,
    },
    #[snafu(display("error while extracting record"))]
    Extraction {
        #[diagnostic_source]
        source: E,

    #[label("in this record")]
    offset: SourceSpan,

        #[label("in this record")]
        offset: SourceSpan,
    },

    type Record<'de>: Deserialize<'de>;

    fn date(&self, _record: &Record) -> Option<Result<Date, Self::Error>> {
        None
    }

    fn date(&self, _record: Self::Record<'_>) -> Date;

        record: &Record,

        record: Self::Record<'_>,

    type Record<'de> = R::Record<'de>;

            fn date(&self, _record: &Record) -> Option<Result<Date, Self::Error>>;

            fn date(&self, record: Self::Record<'_>) -> Date;

                record: &Record,

                record: Self::Record<'_>,

use isin::ISIN;

use rust_decimal::Decimal;

use time::macros::format_description;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_order_date(record))

    fn date(&self, record: Record) -> Date {
        record.date

        record: &csv::Record,

        record: Record,

        const ORDER_ID_COLUMN_INDEX: usize = 3;
        let isin = Commodity::try_from(&record[0]).map_err(|_| todo!())?;
        let security_name = &record[1];
        let date = parse_order_date(record)?;
        let order_id = &record[ORDER_ID_COLUMN_INDEX];
        let transaction_kind = TransactionKind::from_str(&record[4])?;
        let units = german_decimal::parse(&record[5]).map_err(|_| todo!())?;
        let amount = Amount::new(units, isin);
        let security_price = parse_amount(&record[7])?;

        let isin =
            Commodity::try_from(record.isin.to_string()).expect("ISINs are valid commodities");

        let total = parse_amount(&record[9])?;

        let transaction_kind = record.transaction_kind;
        let security_name = record.security_name;
        let order_id = record.order_id;

            TransactionKind::Buy => (amount, CostBasis::PerUnit(security_price), None, -total),
            TransactionKind::Sell => (-amount, CostBasis::Empty, Some(security_price), total),

            TransactionKind::Buy => (
                Amount::new(record.shares, isin),
                CostBasis::PerUnit(record.unit_cost),
                None,
                -record.total_cost,
            ),
            TransactionKind::Sell => (
                -Amount::new(record.shares, isin),
                CostBasis::Empty,
                Some(record.unit_cost),
                record.total_cost,
            ),

        let transaction = Transaction::on(date).tap_mut(|transaction| {

        let transaction = Transaction::on(record.date).tap_mut(|transaction| {

                .add_meta(common_keys::TRANSACTION_ID, order_id)

                .add_meta(common_keys::TRANSACTION_ID, record.order_id)

        let price = Price::new(date, isin, security_price);

        let price = Price::new(record.date, isin, record.unit_cost);

}
#[derive(Clone, Debug, Deserialize)]
// TODO derive Copy once ISIN changes to support that
pub struct Record<'r> {
    #[serde(rename = "Datum", with = "dmy")]
    date: Date,
    #[serde(deserialize_with = "deserialize_isin", rename = "Isin")]
    isin: ISIN,
    #[serde(rename = "Ordernummer")]
    order_id: &'r str,
    #[serde(rename = "Wertpapierbezeichnung")]
    security_name: &'r str,
    #[serde(rename = "Stück", with = "german_decimal::serde")]
    shares: Decimal,
    #[serde(deserialize_with = "deserialize_german_amount", rename = "Kurswert")]
    total_cost: Amount,
    #[serde(rename = "Geschäftsart")]
    transaction_kind: TransactionKind,
    #[serde(deserialize_with = "deserialize_german_amount", rename = "Kurs")]
    unit_cost: Amount,

#[derive(Clone, Copy, Debug)]

#[derive(Clone, Copy, Debug, Deserialize)]

    #[serde(rename = "Kauf")]

    #[serde(rename = "Verkauf")]

fn parse_amount(cost: &str) -> Result<Amount, Error> {
    let (amount, commodity) = cost.split_once(' ').ok_or_else(|| todo!())?;

time::serde::format_description!(dmy, Date, "[day].[month].[year]");
fn deserialize_isin<'de, D>(deserializer: D) -> Result<ISIN, D::Error>
where
    D: serde::Deserializer<'de>,
{
    struct Visitor;
    impl<'de> serde::de::Visitor<'de> for Visitor {
        type Value = ISIN;
        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("an ISIN")
        }

    let amount = german_decimal::parse(amount).map_err(|_| todo!())?;
    let commodity = Commodity::try_from(commodity).map_err(|_| todo!())?;

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            isin::parse(v).map_err(E::custom)
        }
    }

    Ok(Amount::new(amount, commodity))

    deserializer.deserialize_str(Visitor)

fn deserialize_german_amount<'de, D>(deserializer: D) -> Result<Amount, D::Error>
where
    D: serde::Deserializer<'de>,
{
    struct Visitor;

fn parse_order_date(record: &csv::Record) -> Result<Date, Error> {
    use time::format_description::FormatItem;

    impl<'de> serde::de::Visitor<'de> for Visitor {
        type Value = Amount;
        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("an ISIN")
        }
        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            let Some((amount, currency)) = v.split_once(' ') else {
                return Err(E::custom("unexpected format"));
            };

    const DATE_COLUMN_INDEX: usize = 2;
    const DATE_FORMAT: &[FormatItem] = format_description!("[day].[month].[year]");

            let amount = german_decimal::parse(amount).map_err(E::custom)?;
            let currency = Commodity::try_from(currency).map_err(E::custom)?;
            Ok(Amount::new(amount, currency))
        }
    }

    Date::parse(&record[DATE_COLUMN_INDEX], DATE_FORMAT).map_err(|_| todo!())

    deserializer.deserialize_str(Visitor)

isin.workspace           = true

use beancount_types::MetadataKey;

use iso_currency::Currency;

use rust_decimal::Decimal;

use time::format_description::well_known::Iso8601;

use time::Date;

use time_tz::OffsetDateTimeExt as _;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<time::Date, Self::Error>> {
        Some(parse_order_timestamp(record).map(OffsetDateTime::date))

    fn date(&self, record: Record) -> Date {
        Date::max(
            record.order_time.date(),
            record.invoice_date.unwrap_or(Date::MIN),
        )

        record: &csv::Record,

        record: Record,

        const CURRENCY_COLUMN_INDEX: usize = 22;
        const ORDER_ID_COLUMN_INDEX: usize = 19;
        const PRODUCT_NAME_COLUMN_INDEX: usize = 4;
        const ITEM_PRICE_COLUMN_INDEX: usize = 8;
        let order_id = Some(&record[ORDER_ID_COLUMN_INDEX]).filter(|order_id| !order_id.is_empty());
        let timestamp = parse_order_timestamp(record)?;
        let commodity = Commodity::try_from(&record[CURRENCY_COLUMN_INDEX]).unwrap();
        let amount = {
            let amount = &record[ITEM_PRICE_COLUMN_INDEX];
            let (amount, _) = amount.split_once(' ').ok_or_else(|| todo!())?;
            let amount = german_decimal::parse(amount).map_err(|_| todo!())?;
            Amount::new(-amount, commodity)

        let Some(order_id) = record.order_id else {
            return Ok(vec![]);

        let product_name = &record[PRODUCT_NAME_COLUMN_INDEX];

        let commodity = Commodity::try_from(record.currency.code()).unwrap();
        let amount = Amount::new(-record.item_total, commodity);

        let transaction = Transaction::on(timestamp.date()).tap_mut(|transaction| {

        let transaction = Transaction::on(record.order_time.date()).tap_mut(|transaction| {

                .set_payee(&self.config.payee)
                .set_narration(product_name);

                .set_payee(record.seller)
                .set_narration(record.item_description)
                .add_link(Link::try_from(format!("^apple.{order_id}")).expect("valid link"))
                .add_meta(common_keys::TRANSACTION_ID, order_id);

            if let Some(order_id) = order_id {

            if let Some((invoice_date, invoice_id)) =
                record.invoice_date.zip(record.document_number)
            {

                    .add_link(Link::try_from(format!("^apple.{order_id}")).expect("valid link"))
                    .add_meta(common_keys::TRANSACTION_ID, order_id);
            };

                    .add_meta(
                        MetadataKey::try_from("invoice-date").expect("valid key"),
                        invoice_date.to_string(),
                    )
                    .add_meta(
                        MetadataKey::try_from("invoice-id").expect("valid key"),
                        invoice_id,
                    );
            }

                .add_meta(common_keys::TIMESTAMP, timestamp.format(&Rfc3339).unwrap())

                .add_meta(
                    common_keys::TIMESTAMP,
                    record.order_time.format(&Rfc3339).unwrap(),
                )

#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Currency")]
    currency: Currency,
    #[serde(rename = "Document Number")]
    document_number: Option<&'r str>,
    #[serde(rename = "Invoice Date", with = "mdy::option")]
    invoice_date: Option<Date>,
    #[serde(rename = "Item Description")]
    item_description: &'r str,
    #[serde(
        deserialize_with = "deserialize_german_euro_amount",
        rename = "Invoice Item Total"
    )]
    item_total: Decimal,
    #[serde(rename = "Order Number")]
    order_id: Option<&'r str>,
    #[serde(rename = "Item Purchased Date", with = "time::serde::iso8601")]
    order_time: OffsetDateTime,
    #[serde(rename = "Seller")]
    seller: &'r str,
}

time::serde::format_description!(mdy, Date, "[month]/[day]/[year]");

fn parse_order_timestamp(record: &csv::Record) -> Result<OffsetDateTime, Error> {
    const ORDER_TIMESTAMP_COLUMN_INDEX: usize = 1;

fn deserialize_german_euro_amount<'de, D>(deserializer: D) -> Result<Decimal, D::Error>
where
    D: serde::Deserializer<'de>,
{
    struct Visitor;

    parse_timestamp(&record[ORDER_TIMESTAMP_COLUMN_INDEX])
}

    impl<'de> serde::de::Visitor<'de> for Visitor {
        type Value = Decimal;

fn parse_timestamp(input: &str) -> Result<OffsetDateTime, Error> {
    let utc_timestamp = OffsetDateTime::parse(input, &Iso8601::PARSING).map_err(|_| todo!())?;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("an amount with trailing € symbol")
        }

    let timezone = time_tz::system::get_timezone().expect("system timezone");
    let timestamp = utc_timestamp.to_timezone(timezone);

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            let v = v
                .strip_suffix(" €")
                .ok_or_else(|| E::custom("expected symbol suffix not found"))?
                .trim();

    Ok(timestamp)

            german_decimal::parse(v).map_err(E::custom)
        }
    }
    deserializer.deserialize_str(Visitor)

use iso_currency::Country;

use time::PrimitiveDateTime;
use time_tz::system;
use time_tz::PrimitiveDateTimeExt;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_record_timestamp(record).map(OffsetDateTime::date))

    fn date(&self, record: Record) -> Date {
        record.transaction_date.date()

        record: &csv::Record,

        record: Record,

        const AMOUNT_COLUMN_INDEX: usize = 3;
        const COUNTRY_COLUMN_INDEX: usize = 1;
        const ORDER_ID_COLUMN_INDEX: usize = 2;
        const TRANSACTION_KIND_COLUMN_INDEX: usize = 4;
        let timestamp = parse_record_timestamp(record)?;
        let country = &record[COUNTRY_COLUMN_INDEX];
        let commodity = match country {
            "DE" => Commodity::try_from("EUR").unwrap(),

        let commodity = match record.country {
            Country::DE => Commodity::try_from("EUR").unwrap(),

        let transaction_id = &record[ORDER_ID_COLUMN_INDEX];

        let transaction_id = record.order_number;

        let kind = TransactionKind::try_from(&record[TRANSACTION_KIND_COLUMN_INDEX])?;
        let amount = {
            let amount = &record[AMOUNT_COLUMN_INDEX];
            let amount = Decimal::from_str(amount).map_err(|_| todo!())?;
            Amount::new(amount, commodity)
        };

        let kind = TransactionKind::try_from(record.transaction_type)?;
        let amount = Amount::new(record.amount, commodity);

                let mut transaction = Transaction::on(timestamp.date());

                let mut transaction = Transaction::on(record.transaction_date.date());

                        timestamp.format(&Rfc3339).map_err(|_| todo!())?,

                        record
                            .transaction_date
                            .format(&Rfc3339)
                            .map_err(|_| todo!())?,

                let mut transaction = Transaction::on(timestamp.date());

                let mut transaction = Transaction::on(record.transaction_date.date());

                        timestamp.format(&Rfc3339).map_err(|_| todo!())?,

                        record
                            .transaction_date
                            .format(&Rfc3339)
                            .map_err(|_| todo!())?,

}
#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Amount")]
    amount: Decimal,
    #[serde(rename = "Country")]
    country: Country,
    #[serde(rename = "Order number")]
    order_number: &'r str,
    #[serde(
        rename = "Transaction date",
        deserialize_with = "deserialize_local_offset_date_time"
    )]
    transaction_date: OffsetDateTime,
    #[serde(rename = "Transaction type")]
    transaction_type: &'r str,

fn parse_record_timestamp(record: &csv::Record) -> Result<OffsetDateTime, Error> {
    const DATE_COLUMN_INDEX: usize = 0;

fn deserialize_local_offset_date_time<'de, D>(deserializer: D) -> Result<OffsetDateTime, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::de::Error as _;
    use time_tz::system;
    use time_tz::PrimitiveDateTimeExt as _;
    use time_tz::TimeZone as _;

    let timestamp = PrimitiveDateTime::parse(&record[DATE_COLUMN_INDEX], &Iso8601::PARSING)
        .map_err(|error| {
            dbg!(error);
            todo!()
        })?;

    let timestamp = iso_primitivedatetime::deserialize(deserializer)?;

    let tz = system::get_timezone().map_err(|_| todo!())?;
    timestamp
        .assume_timezone(tz)
        .take_first()
        .ok_or_else(|| todo!())

    let tz = system::get_timezone().map_err(D::Error::custom)?;
    timestamp.assume_timezone(tz).take_first().ok_or_else(|| {
        D::Error::custom(format!(
            "invalid datetime {timestamp} in timezone {}",
            tz.name()
        ))
    })

const PRIMITIVE_DATE_TIME_FORMAT: Iso8601<0> =
    time::format_description::well_known::Iso8601::PARSING;
time::serde::format_description!(
    iso_primitivedatetime,
    PrimitiveDateTime,
    PRIMITIVE_DATE_TIME_FORMAT
);

iso_country.workspace    = true
iso_currency.workspace   = true

use time::Date;

use time::PrimitiveDateTime;
use time_tz::OffsetDateTimeExt as _;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<time::Date, Self::Error>> {
        Some(parse_order_timestamp(record).map(OffsetDateTime::date))

    fn date(&self, record: Record) -> Date {
        record.order_timestamp.date()

        record: &csv::Record,

        record: Record,

        const ASIN_COLUMN_INDEX: usize = 12;
        const CURRENCY_COLUMN_INDEX: usize = 4;
        const ORDER_ID_COLUMN_INDEX: usize = 1;
        const PRODUCT_NAME_COLUMN_INDEX: usize = 23;
        const TOTAL_OWED_COLUMN_INDEX: usize = 9;

        dbg!(record);

        let order_id = &record[ORDER_ID_COLUMN_INDEX];
        let timestamp = parse_order_timestamp(record)?;

        let order_id = record.order_id;

        let commodity = Commodity::try_from(&record[CURRENCY_COLUMN_INDEX]).unwrap();

            let amount = Decimal::from_str(&record[TOTAL_OWED_COLUMN_INDEX])
                .unwrap()
                .tap_mut(|amount| amount.rescale(2));
            Amount::new(amount, commodity)

            Amount::new(
                record.total_owed.tap_mut(|amount| amount.rescale(2)),
                record.currency,
            )

        let asin = &record[ASIN_COLUMN_INDEX];
        let product_name = &record[PRODUCT_NAME_COLUMN_INDEX];

        let asin = record.asin;
        let product_name = record.product_name;

        let transaction = Transaction::on(timestamp.date()).tap_mut(|transaction| {

        let transaction = Transaction::on(record.order_timestamp.date()).tap_mut(|transaction| {

                let currency: &str = &commodity;

                let currency: &str = &record.currency;

                .add_meta(common_keys::TIMESTAMP, timestamp.format(&Rfc3339).unwrap())

                .add_meta(
                    common_keys::TIMESTAMP,
                    record.order_timestamp.format(&Rfc3339).unwrap(),
                )

#[derive(Clone, Copy, Debug, Deserialize)]
pub struct Record<'r> {
    #[serde(rename = "Order ID")]
    order_id: &'r str,
    #[serde(rename = "Order Date", with = "time::serde::iso8601")]
    order_timestamp: OffsetDateTime,
    #[serde(rename = "Currency")]
    currency: Commodity,
    #[serde(rename = "Total Owed")]
    total_owed: Decimal,

    #[serde(rename = "ASIN")]
    asin: &'r str,
    #[serde(rename = "Product Name")]
    product_name: &'r str,
}

}
fn parse_order_timestamp(record: &csv::Record) -> Result<OffsetDateTime, Error> {
    const ORDER_DATE_COLUMN_INDEX: usize = 2;
    parse_timestamp(&record[ORDER_DATE_COLUMN_INDEX])

fn parse_timestamp(input: &str) -> Result<OffsetDateTime, Error> {
    let utc_timestamp = PrimitiveDateTime::parse(input, &Rfc3339)
        .unwrap()
        .assume_utc();
    let timezone = time_tz::system::get_timezone().expect("system timezone");
    let timestamp = utc_timestamp.to_timezone(timezone);
    Ok(timestamp)
}

use time::macros::format_description;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<Date, Self::Error>> {
        Some(parse_record_date(record))

    fn date(&self, record: Record) -> Date {
        record.date

        record: &csv::Record,

        record: Record,

        let date = parse_record_date(record)?;

        let date = record.date;

        let description = &record[1];
        let kind = TransactionKind::try_from(description).unwrap();

            let amount = &record[2];

            let amount = record.amount;

            transaction.set_narration(description);

            transaction.set_narration(record.kind.to_string());

            match kind {

            match record.kind {

fn parse_record_date(record: &csv::Record) -> Result<Date, Error> {
    const DATE_COLUMN_INDEX: usize = 0;
    const DATE_FORMAT: &[time::format_description::FormatItem] =
        format_description!("[day] [month repr:long] [year]");

#[derive(Clone, Copy, Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Record<'r> {
    #[serde(with = "dm_long_y")]
    date: Date,
    #[serde(rename = "Description")]
    kind: TransactionKind<'r>,

    Date::parse(&record[DATE_COLUMN_INDEX], DATE_FORMAT).map_err(|_| todo!())

    amount: &'r str,

time::serde::format_description!(dm_long_y, Date, "[day] [month repr:long] [year]");

#[derive(Clone, Copy, Debug)]

#[derive(Clone, Copy, Debug, Deserialize)]
#[serde(try_from = "&str")]

            TransactionKind::Claim { .. } => f.write_str("Gift Card Claim"),
            TransactionKind::Payment { .. } => f.write_str("Payment"),
            TransactionKind::TopUp { .. } => f.write_str("Balance Top Up"),

            TransactionKind::Claim { claim_code } => write!(f, "Claim gift card {claim_code}"),
            TransactionKind::Payment { order_id } => write!(f, "Payment towards order {order_id}"),
            TransactionKind::TopUp { order_id } => write!(f, "Balance top up in order {order_id}"),

    type Error = (); // TODO

    type Error = &'static str; // TODO

use time::macros::format_description;

    type Record<'de> = Record<'de>;

    fn date(&self, record: &csv::Record) -> Option<Result<time::Date, Self::Error>> {
        Some(parse_order_date(record))

    fn date(&self, record: Record) -> Date {
        Date::max(
            record.order_date,
            record.fulfilled_date.unwrap_or(Date::MIN),
        )

        record: &csv::Record,

        record: Record,

        const ASIN_COLUMN_INDEX: usize = 0;
        const CURRENCY_COLUMN_INDEX: usize = 14;
        const ORDER_ID_COLUMN_INDEX: usize = 2;
        const PRODUCT_NAME_COLUMN_INDEX: usize = 1;
        const TOTAL_OWED_COLUMN_INDEX: usize = 13;
        let date = parse_order_date(record)?;

        let date = record.order_date;

        let asin = &record[ASIN_COLUMN_INDEX];
        let product_name = &record[PRODUCT_NAME_COLUMN_INDEX];
        let order_id = &record[ORDER_ID_COLUMN_INDEX];

        let asin = record.asin;
        let product_name = record.title;
        let order_id = record.order_id;

        let commodity = Commodity::try_from(&record[CURRENCY_COLUMN_INDEX]).unwrap();
        let amount = {
            let amount = Decimal::from_str(&record[TOTAL_OWED_COLUMN_INDEX])
                .unwrap()
                .tap_mut(|amount| amount.rescale(2));
            Amount::new(amount, commodity)
        };

        let amount = Amount::new(
            record.our_price_tax.tap_mut(|amount| amount.rescale(2)),
            record.our_price_tax_currency_code,
        );

                let currency: &str = &commodity;

                let currency: &str = &record.our_price_tax_currency_code;

                .set_payee(record.seller_of_record)

#[derive(Clone, Copy, Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Record<'r> {
    #[serde(rename = "ASIN")]
    asin: &'r str,

    fulfilled_date: Option<Date>,
    order_date: Date,
    order_id: &'r str,
    our_price_tax: Decimal,
    our_price_tax_currency_code: Commodity,
    seller_of_record: &'r str,
    #[serde(rename = "Title")]
    title: &'r str,
}

}
fn parse_order_date(record: &csv::Record) -> Result<Date, Error> {
    const ORDER_DATE_COLUMN_INDEX: usize = 9;
    parse_date(&record[ORDER_DATE_COLUMN_INDEX])

fn parse_date(input: &str) -> Result<Date, Error> {
    use time::format_description::FormatItem;
    const ORDER_DATE_FORMAT: &[FormatItem] = format_description!("[year]-[month]-[day]");
    Date::parse(input, ORDER_DATE_FORMAT).map_err(|_| todo!())
}

use rust_decimal::Decimal;
pub mod opt {
    use rust_decimal::Decimal;
    #[allow(non_camel_case_types)]
    pub struct with_precision<const PRECISION: u32>;
    impl<const PRECISION: u32> with_precision<PRECISION> {
        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Decimal>, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            struct Visitor<const PRECISION: u32>;
            impl<'de, const PRECISION: u32> serde::de::Visitor<'de> for Visitor<PRECISION> {
                type Value = Option<Decimal>;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("an optional decimal number in german format")
                }
                fn visit_none<E>(self) -> Result<Self::Value, E>
                where
                    E: serde::de::Error,
                {
                    Ok(None)
                }
                fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    super::with_precision::<PRECISION>::deserialize(deserializer).map(Some)
                }
            }
            deserializer.deserialize_option(Visitor::<PRECISION>)
        }
    }
    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Decimal>, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Option<Decimal>;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("an optional decimal number in german format")
            }
            fn visit_none<E>(self) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                Ok(None)
            }
            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                super::deserialize(deserializer).map(Some)
            }
        }
        deserializer.deserialize_option(Visitor)
    }
}
#[allow(non_camel_case_types)]
pub struct with_precision<const PRECISION: u32>;
impl<const PRECISION: u32> with_precision<PRECISION> {
    pub fn deserialize<'de, D>(deserializer: D) -> Result<Decimal, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct Visitor<const PRECISION: u32>;
        impl<'de, const PRECISION: u32> serde::de::Visitor<'de> for Visitor<PRECISION> {
            type Value = Decimal;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("a decimal number in german format")
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                let mut amount = crate::parse(v).map_err(E::custom)?;
                amount.rescale(PRECISION);
                Ok(amount)
            }
        }
        deserializer.deserialize_str(Visitor::<PRECISION>)
    }
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<Decimal, D::Error>
where
    D: serde::Deserializer<'de>,
{
    struct Visitor;
    impl<'de> serde::de::Visitor<'de> for Visitor {
        type Value = Decimal;
        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a decimal number in german format")
        }
        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            crate::parse(v).map_err(E::custom)
        }
    }
    deserializer.deserialize_str(Visitor)
}