#!/usr/bin/env python3
"""Run: python clean_sales.py INPUT.csv --output-dir results
Reads named headers; preserves original cell values except region and added line_sales.
Exact duplicates are compared across all original columns before normalization.
"""
import argparse, csv, hashlib, json
from collections import defaultdict
from datetime import date
from decimal import Decimal
from pathlib import Path


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument('input', type=Path)
    ap.add_argument('--output-dir', type=Path, default=Path('results'))
    args = ap.parse_args()
    before = hashlib.sha256(args.input.read_bytes()).hexdigest()
    with args.input.open(encoding='utf-8-sig', newline='') as f:
        reader = csv.DictReader(f)
        columns = reader.fieldnames
        required = {'order_id','order_date','region','units','unit_price'}
        if not columns or len(set(columns)) != len(columns) or not required.issubset(columns):
            raise ValueError('Missing required or duplicate column names')
        if 'line_sales' in columns:
            raise ValueError('Input already has line_sales; refusing to overwrite a source value')
        rows = list(reader)
    groups = defaultdict(list)
    for number, row in enumerate(rows, 1):
        if None in row or any(v is None for v in row.values()):
            raise ValueError(f'Malformed CSV record {number}')
        groups[tuple(row[c] for c in columns)].append(number)
    duplicates = [{'data_row_numbers': nums, 'occurrences': len(nums), 'extra_copies': len(nums)-1,
                   'record': dict(zip(columns, key))} for key, nums in groups.items() if len(nums)>1]
    blank = [{'data_row_number': i, 'record': r} for i,r in enumerate(rows,1) if not r['order_id'].strip()]
    clean, seen, north = [], set(), []
    total_sales, total_units, squares = Decimal(0), Decimal(0), Decimal(0)
    monthly, regional, combined = defaultdict(Decimal), defaultdict(Decimal), defaultdict(Decimal)
    removed_duplicates = 0
    for i, r in enumerate(rows,1):
        if not r['order_id'].strip():
            continue
        key = tuple(r[c] for c in columns)
        if key in seen:
            removed_duplicates += 1
            continue
        seen.add(key)
        out = dict(r)
        out['region'] = r['region'].strip().title() or 'Unknown'
        units, price = Decimal(r['units']), Decimal(r['unit_price'])
        if not units.is_finite() or not price.is_finite():
            raise ValueError(f'Nonfinite numeric value at data row {i}')
        sales = units * price
        month = date.fromisoformat(r['order_date']).strftime('%Y-%m')
        out['line_sales'] = format(sales, 'f')
        clean.append(out)
        total_sales += sales
        total_units += units
        squares += units ** 2
        monthly[month] += sales
        regional[out['region']] += sales
        combined[(month,out['region'])] += sales
        if out['region'] == 'North':
            north.append({'source_data_row_number': i, 'record': out})
    args.output_dir.mkdir(parents=True, exist_ok=True)
    with (args.output_dir/'cleaned_sales.csv').open('w', encoding='utf-8', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=columns+['line_sales'])
        writer.writeheader()
        writer.writerows(clean)
    # Decimal values are serialized as exact decimal strings, not binary floats.
    results = {'raw_source': {'column_names': columns, 'data_row_count': len(rows),
               'exact_duplicate_groups': duplicates, 'blank_order_id_records': blank,
               'sha256': before},
               'cleaning': {'blank_id_rows_excluded': len(blank), 'extra_duplicate_rows_removed': removed_duplicates,
               'duplicate_basis': 'all original CSV cell values before region normalization',
               'region_rule': 'strip whitespace, title case, empty becomes Unknown',
               'other_values': 'preserved, including nonblank order_id whitespace'},
               'clean_record_count': len(clean), 'total_sales': total_sales,
               'total_units': total_units, 'sum_squared_units': squares,
               'sales_by_calendar_month': dict(sorted(monthly.items())),
               'sales_by_region': dict(sorted(regional.items())),
               'sales_by_calendar_month_and_region': [{'calendar_month': m,'region': r,'sales': s} for (m,r),s in sorted(combined.items())],
               'north_contributing_records': north,
               'decimal_encoding': 'exact decimal strings',
               'source_unchanged': before == hashlib.sha256(args.input.read_bytes()).hexdigest()}
    text = json.dumps(results, indent=2, default=str)
    (args.output_dir/'sales_results.json').write_text(text+'\n', encoding='utf-8')
    print(text)

if __name__ == '__main__':
    main()
