from __future__ import annotations

import sqlite3
from pathlib import Path
from typing import Any

from .legacy_parser import (
    ACCOUNT_FIELDS,
    CARD_FIELDS,
    CARD_XREF_FIELDS,
    CUSTOMER_FIELDS,
    DISCLOSURE_GROUP_FIELDS,
    TRANSACTION_CATEGORY_BALANCE_FIELDS,
    TRANSACTION_CATEGORY_FIELDS,
    TRANSACTION_FIELDS,
    TRANSACTION_TYPE_FIELDS,
    parse_ascii_file,
    parse_pending_authorizations,
    parse_user_security,
)


SCHEMA = """
PRAGMA foreign_keys = ON;

CREATE TABLE IF NOT EXISTS customers (
    customer_id INTEGER PRIMARY KEY,
    first_name TEXT NOT NULL,
    middle_name TEXT NOT NULL,
    last_name TEXT NOT NULL,
    address_line_1 TEXT NOT NULL,
    address_line_2 TEXT NOT NULL,
    address_line_3 TEXT NOT NULL,
    state TEXT NOT NULL,
    country TEXT NOT NULL,
    zip_code TEXT NOT NULL,
    phone_1 TEXT NOT NULL,
    phone_2 TEXT NOT NULL,
    ssn TEXT NOT NULL,
    government_id TEXT NOT NULL,
    date_of_birth TEXT NOT NULL,
    eft_account_id TEXT NOT NULL,
    primary_card_holder TEXT NOT NULL,
    fico_score INTEGER NOT NULL
);

CREATE TABLE IF NOT EXISTS accounts (
    account_id INTEGER PRIMARY KEY,
    active_status TEXT NOT NULL,
    current_balance_cents INTEGER NOT NULL,
    credit_limit_cents INTEGER NOT NULL,
    cash_credit_limit_cents INTEGER NOT NULL,
    open_date TEXT NOT NULL,
    expiration_date TEXT NOT NULL,
    reissue_date TEXT NOT NULL,
    current_cycle_credit_cents INTEGER NOT NULL,
    current_cycle_debit_cents INTEGER NOT NULL,
    zip_code TEXT NOT NULL,
    group_id TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS cards (
    card_number TEXT PRIMARY KEY,
    account_id INTEGER NOT NULL,
    cvv TEXT NOT NULL,
    embossed_name TEXT NOT NULL,
    expiration_date TEXT NOT NULL,
    active_status TEXT NOT NULL,
    FOREIGN KEY(account_id) REFERENCES accounts(account_id)
);

CREATE TABLE IF NOT EXISTS card_xrefs (
    card_number TEXT PRIMARY KEY,
    customer_id INTEGER NOT NULL,
    account_id INTEGER NOT NULL,
    FOREIGN KEY(customer_id) REFERENCES customers(customer_id),
    FOREIGN KEY(account_id) REFERENCES accounts(account_id)
);

CREATE TABLE IF NOT EXISTS transactions (
    transaction_id TEXT PRIMARY KEY,
    type_code TEXT NOT NULL,
    category_code TEXT NOT NULL,
    source TEXT NOT NULL,
    description TEXT NOT NULL,
    amount_cents INTEGER NOT NULL,
    merchant_id TEXT NOT NULL,
    merchant_name TEXT NOT NULL,
    merchant_city TEXT NOT NULL,
    merchant_zip TEXT NOT NULL,
    card_number TEXT NOT NULL,
    original_timestamp TEXT NOT NULL,
    processed_timestamp TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS transaction_types (
    type_code TEXT PRIMARY KEY,
    description TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS transaction_categories (
    type_code TEXT NOT NULL,
    category_code TEXT NOT NULL,
    description TEXT NOT NULL,
    PRIMARY KEY(type_code, category_code)
);

CREATE TABLE IF NOT EXISTS disclosure_groups (
    group_id TEXT NOT NULL,
    type_code TEXT NOT NULL,
    category_code TEXT NOT NULL,
    interest_rate_basis_points INTEGER NOT NULL,
    PRIMARY KEY(group_id, type_code, category_code)
);

CREATE TABLE IF NOT EXISTS transaction_category_balances (
    account_id INTEGER NOT NULL,
    type_code TEXT NOT NULL,
    category_code TEXT NOT NULL,
    balance_cents INTEGER NOT NULL,
    PRIMARY KEY(account_id, type_code, category_code),
    FOREIGN KEY(account_id) REFERENCES accounts(account_id)
);

CREATE TABLE IF NOT EXISTS users (
    user_id TEXT PRIMARY KEY,
    first_name TEXT NOT NULL,
    last_name TEXT NOT NULL,
    password TEXT NOT NULL,
    user_type TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS pending_authorization_summaries (
    account_id INTEGER PRIMARY KEY,
    customer_id INTEGER NOT NULL,
    sequence_no INTEGER NOT NULL,
    auth_status TEXT NOT NULL,
    account_status_1 TEXT NOT NULL,
    account_status_2 TEXT NOT NULL,
    account_status_3 TEXT NOT NULL,
    account_status_4 TEXT NOT NULL,
    account_status_5 TEXT NOT NULL,
    credit_limit_cents INTEGER NOT NULL,
    cash_limit_cents INTEGER NOT NULL,
    credit_balance_cents INTEGER NOT NULL,
    cash_balance_cents INTEGER NOT NULL,
    approved_auth_count INTEGER NOT NULL,
    declined_auth_count INTEGER NOT NULL,
    approved_auth_amount_cents INTEGER NOT NULL,
    declined_auth_amount_cents INTEGER NOT NULL,
    FOREIGN KEY(account_id) REFERENCES accounts(account_id),
    FOREIGN KEY(customer_id) REFERENCES customers(customer_id)
);

CREATE TABLE IF NOT EXISTS pending_authorization_details (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    account_id INTEGER NOT NULL,
    sequence_no INTEGER NOT NULL,
    authorization_key TEXT NOT NULL,
    auth_date_key INTEGER NOT NULL,
    auth_time_key INTEGER NOT NULL,
    auth_yyddd INTEGER NOT NULL,
    auth_orig_date TEXT NOT NULL,
    auth_orig_time TEXT NOT NULL,
    card_number TEXT NOT NULL,
    auth_type TEXT NOT NULL,
    card_expiry_date TEXT NOT NULL,
    message_type TEXT NOT NULL,
    message_source TEXT NOT NULL,
    auth_id_code TEXT NOT NULL,
    auth_resp_code TEXT NOT NULL,
    auth_resp_reason TEXT NOT NULL,
    processing_code TEXT NOT NULL,
    transaction_amount_cents INTEGER NOT NULL,
    approved_amount_cents INTEGER NOT NULL,
    merchant_category_code TEXT NOT NULL,
    acqr_country_code TEXT NOT NULL,
    pos_entry_mode TEXT NOT NULL,
    merchant_id TEXT NOT NULL,
    merchant_name TEXT NOT NULL,
    merchant_city TEXT NOT NULL,
    merchant_state TEXT NOT NULL,
    merchant_zip TEXT NOT NULL,
    transaction_id TEXT NOT NULL,
    match_status TEXT NOT NULL,
    auth_fraud TEXT NOT NULL,
    fraud_rpt_date TEXT NOT NULL,
    UNIQUE(account_id, authorization_key),
    FOREIGN KEY(account_id) REFERENCES pending_authorization_summaries(account_id) ON DELETE CASCADE
);

CREATE TABLE IF NOT EXISTS authorization_frauds (
    card_number TEXT NOT NULL,
    auth_timestamp TEXT NOT NULL,
    account_id INTEGER NOT NULL,
    customer_id INTEGER NOT NULL,
    authorization_key TEXT NOT NULL,
    auth_type TEXT NOT NULL,
    card_expiry_date TEXT NOT NULL,
    message_type TEXT NOT NULL,
    message_source TEXT NOT NULL,
    auth_id_code TEXT NOT NULL,
    auth_resp_code TEXT NOT NULL,
    auth_resp_reason TEXT NOT NULL,
    processing_code TEXT NOT NULL,
    transaction_amount_cents INTEGER NOT NULL,
    approved_amount_cents INTEGER NOT NULL,
    merchant_category_code TEXT NOT NULL,
    acqr_country_code TEXT NOT NULL,
    pos_entry_mode TEXT NOT NULL,
    merchant_id TEXT NOT NULL,
    merchant_name TEXT NOT NULL,
    merchant_city TEXT NOT NULL,
    merchant_state TEXT NOT NULL,
    merchant_zip TEXT NOT NULL,
    transaction_id TEXT NOT NULL,
    match_status TEXT NOT NULL,
    auth_fraud TEXT NOT NULL,
    fraud_rpt_date TEXT NOT NULL,
    PRIMARY KEY(card_number, auth_timestamp)
);

CREATE TABLE IF NOT EXISTS modernization_meta (
    key TEXT PRIMARY KEY,
    value TEXT NOT NULL
);
"""


def connect(db_path: Path) -> sqlite3.Connection:
    conn = sqlite3.connect(str(db_path))
    conn.row_factory = sqlite3.Row
    conn.execute("PRAGMA foreign_keys = ON")
    return conn


def initialize_schema(conn: sqlite3.Connection) -> None:
    conn.executescript(SCHEMA)
    conn.commit()


def reset_database(conn: sqlite3.Connection) -> None:
    initialize_schema(conn)
    for table in (
        "authorization_frauds",
        "pending_authorization_details",
        "pending_authorization_summaries",
        "transactions",
        "transaction_category_balances",
        "card_xrefs",
        "cards",
        "accounts",
        "customers",
        "transaction_categories",
        "transaction_types",
        "disclosure_groups",
        "users",
        "modernization_meta",
    ):
        conn.execute(f"DELETE FROM {table}")
    conn.commit()


def insert_many(conn: sqlite3.Connection, table: str, rows: list[dict[str, Any]]) -> None:
    if not rows:
        return
    columns = list(rows[0].keys())
    placeholders = ", ".join("?" for _ in columns)
    col_sql = ", ".join(columns)
    values = [[row[column] for column in columns] for row in rows]
    conn.executemany(f"INSERT OR REPLACE INTO {table} ({col_sql}) VALUES ({placeholders})", values)


def seed_from_legacy(source_root: Path, db_path: Path, *, reset: bool = True) -> dict[str, int]:
    data = source_root / "app" / "data"
    conn = connect(db_path)
    try:
        if reset:
            reset_database(conn)
        else:
            initialize_schema(conn)

        customers = parse_ascii_file(data / "ASCII" / "custdata.txt", CUSTOMER_FIELDS, 500)
        accounts = parse_ascii_file(data / "ASCII" / "acctdata.txt", ACCOUNT_FIELDS, 300)
        cards = parse_ascii_file(data / "ASCII" / "carddata.txt", CARD_FIELDS, 150)
        xrefs = parse_ascii_file(data / "ASCII" / "cardxref.txt", CARD_XREF_FIELDS, 50)
        transactions = parse_ascii_file(data / "ASCII" / "dailytran.txt", TRANSACTION_FIELDS, 350)
        transaction_types = parse_ascii_file(data / "ASCII" / "trantype.txt", TRANSACTION_TYPE_FIELDS, 60)
        transaction_categories = parse_ascii_file(
            data / "ASCII" / "trancatg.txt", TRANSACTION_CATEGORY_FIELDS, 60
        )
        disclosure_groups = parse_ascii_file(data / "ASCII" / "discgrp.txt", DISCLOSURE_GROUP_FIELDS, 50)
        transaction_category_balances = parse_ascii_file(
            data / "ASCII" / "tcatbal.txt", TRANSACTION_CATEGORY_BALANCE_FIELDS, 50
        )
        users = parse_user_security(data / "EBCDIC" / "AWS.M2.CARDDEMO.USRSEC.PS")
        pending_authorizations = parse_pending_authorizations(
            source_root
            / "app"
            / "app-authorization-ims-db2-mq"
            / "data"
            / "EBCDIC"
            / "AWS.M2.CARDDEMO.IMSDATA.DBPAUTP0.dat"
        )

        insert_many(conn, "customers", customers)
        insert_many(conn, "accounts", accounts)
        insert_many(conn, "cards", cards)
        insert_many(conn, "card_xrefs", xrefs)
        insert_many(conn, "transactions", transactions)
        insert_many(conn, "transaction_types", transaction_types)
        insert_many(conn, "transaction_categories", transaction_categories)
        insert_many(conn, "disclosure_groups", disclosure_groups)
        insert_many(conn, "transaction_category_balances", transaction_category_balances)
        insert_many(conn, "users", users)
        insert_many(conn, "pending_authorization_summaries", pending_authorizations["summaries"])
        insert_many(conn, "pending_authorization_details", pending_authorizations["details"])
        conn.execute(
            "INSERT OR REPLACE INTO modernization_meta(key, value) VALUES (?, ?)",
            ("source_root", str(source_root.resolve())),
        )
        conn.commit()
        return {
            "customers": len(customers),
            "accounts": len(accounts),
            "cards": len(cards),
            "card_xrefs": len(xrefs),
            "transactions": len(transactions),
            "transaction_types": len(transaction_types),
            "transaction_categories": len(transaction_categories),
            "disclosure_groups": len(disclosure_groups),
            "transaction_category_balances": len(transaction_category_balances),
            "users": len(users),
            "pending_authorization_summaries": len(pending_authorizations["summaries"]),
            "pending_authorization_details": len(pending_authorizations["details"]),
        }
    finally:
        conn.close()


def row_to_dict(row: sqlite3.Row | None) -> dict[str, Any] | None:
    return dict(row) if row is not None else None


def rows_to_dicts(rows: list[sqlite3.Row]) -> list[dict[str, Any]]:
    return [dict(row) for row in rows]