import csv

from util.db import get_latin_names_batch
from util.var import BATCH_SIZE, BUCKET_LIST, MAJOR_RANKS, TAXONOMY_ORDER


def write_csv(
    data,
    output_file,
    sample_id,
    total_reads,
    lineage_lookup,
    target_level,
    damage_enabled,
    conn,
):
    target_rank_index = MAJOR_RANKS.index(target_level.lower())
    header_ranks = [
        rank.capitalize()
        for rank in MAJOR_RANKS
        if MAJOR_RANKS.index(rank) <= target_rank_index
    ]

    csv_header = header_ranks + [
        "taxid_at_target_level",
        "read_count",
        "read_percent",
        "sample_id",
        "nm_min",
        "nm_max",
        "nm_avg",
        "nm_std",
        "as_min",
        "as_max",
        "as_avg",
        "as_std",
        "xm_min",
        "xm_max",
        "xm_avg",
        "xm_std",
    ]
    if damage_enabled:
        csv_header += ["ds_min", "ds_max", "ds_avg", "ds_std"] + BUCKET_LIST

    all_taxids_to_name = set()
    for target_taxid, data_entry in data.items():
        if target_taxid not in ["Unknown", "Other"]:
            all_taxids_to_name.add(int(target_taxid))
            lineage = lineage_lookup.get(target_taxid, {})
            for taxid in lineage.values():
                if taxid not in ["Unknown", "Other"]:
                    all_taxids_to_name.add(int(taxid))

    # Fetch all scientific names in one batch
    latin_name_map = get_latin_names_batch(list(all_taxids_to_name), conn)

    with open(output_file, "w", newline="") as file:
        csvfile = csv.writer(file)
        csvfile.writerow(csv_header)
        # Sort based on read count
        sorted_data = sorted(
            data.items(), key=lambda item: item[1]["count"], reverse=True
        )

        for target_taxid, data_entry in sorted_data:
            row_data = []

            # --- Lineage Data Population ---
            lineage = lineage_lookup.get(target_taxid, {})
            for rank in MAJOR_RANKS:
                if MAJOR_RANKS.index(rank) <= target_rank_index:
                    taxid = lineage.get(
                        rank, "Other" if target_taxid == "Other" else "Unknown"
                    )
                    name = latin_name_map.get(taxid, taxid)
                    if taxid in ["Unknown", "Other"]:
                        name = taxid

                    row_data.append(name)

            count = data_entry["count"]

            # --- Descriptive Stats ---
            def calculate_stats(scores):
                if not scores:
                    return "N/A", "N/A", "N/A", "N/A"
                val_min = min(scores)
                val_max = max(scores)
                avg_raw = sum(scores) / len(scores)
                val_avg = round(avg_raw, 2)
                if len(scores) > 1:
                    variance = sum((x - avg_raw) ** 2 for x in scores) / len(scores)
                    val_std = round(variance**0.5, 2)
                else:
                    val_std = 0.0
                return val_min, val_max, val_avg, val_std

            # --- QA Metrics ---
            nm_min, nm_max, nm_avg, nm_std = calculate_stats(
                data_entry.get("nm_scores", [])
            )
            as_min, as_max, as_avg, as_std = calculate_stats(
                data_entry.get("as_scores", [])
            )
            xm_min, xm_max, xm_avg, xm_std = calculate_stats(
                data_entry.get("xm_scores", [])
            )

            # --- Damage Score Stats ---
            ds_scores = data_entry.get("ds_scores", [])
            ds_min, ds_max, ds_avg, ds_std = calculate_stats(ds_scores)

            # --- Final Row Assembly ---
            read_percent = round(count / total_reads * 100, 4)

            row_data.append(target_taxid)
            row_data.append(count)
            row_data.append(read_percent)
            row_data.append(sample_id)

            row_data.extend([nm_min, nm_max, nm_avg, nm_std])
            row_data.extend([as_min, as_max, as_avg, as_std])
            row_data.extend([xm_min, xm_max, xm_avg, xm_std])

            if damage_enabled:
                # DS STATS
                row_data.append(ds_min)
                row_data.append(ds_max)
                row_data.append(ds_avg)
                row_data.append(ds_std)

                # NEW DS BUCKET COUNTS
                for x in BUCKET_LIST:
                    row_data.append(data_entry["buckets"][x])

            csvfile.writerow(row_data)


def print_report(data, total_reads, input_file, output_file, exec_time, target_level):
    print(f"Input File: {input_file}")
    print(f"Target Level: {target_level}")
    print(f"Output File: {output_file}")
    print(f"Processing Time: {exec_time} sec")
    print(f"  TOTAL READS: {total_reads}")

    unknown_reads = data.get("Unknown", {"count": 0})["count"]
    other_reads = data.get("Other", {"count": 0})["count"]
    classified_reads = total_reads - unknown_reads - other_reads
    taxid_count = len(data)

    print(f"  TOTAL {target_level.upper()} IDs: {taxid_count}")

    unknown_reads_percent = (
        round(unknown_reads / total_reads * 100, 2) if total_reads else 0
    )
    other_reads_percent = (
        round(other_reads / total_reads * 100, 2) if total_reads else 0
    )
    classified_reads_percent = (
        round(classified_reads / total_reads * 100, 2) if total_reads else 0
    )
    other_reads_percent = (
        round(other_reads / total_reads * 100, 2) if total_reads else 0
    )
    classified_reads_percent = (
        round(classified_reads / total_reads * 100, 2) if total_reads else 0
    )
    classified_reads_percent = round(classified_reads / total_reads * 100, 2) if total_reads else 0

    print(f"  Unknown Reads: {unknown_reads} ({unknown_reads_percent}%)")
    print(f"  Other Reads: {other_reads} ({other_reads_percent}%)")
    print(f"  Classified Reads: {classified_reads} ({classified_reads_percent}%)")
