import os
import sys
import glob
import csv
from typing import List, Optional, Dict, Any
from pathlib import Path
from pydantic import BaseModel, Field, ValidationError

# Enforce external dependency 'orjson' with safe fallback diagnostics
try:
    import orjson
except ImportError:
    print("[!] Critical Error: Mandatory dependency 'orjson' is missing.", file=sys.stderr)
    print("[!] Ensure all required dependencies are installed in your runtime environment:", file=sys.stderr)
    print("    pip install orjson charset-normalizer pydantic", file=sys.stderr)
    sys.exit(1)

from charset_normalizer import from_path

# ==========================================
# 1. Pydantic v2 Data Contract Definitions
# ==========================================
class CSVRowSchema(BaseModel):
    id: int = Field(..., description="Unique record identifier (numeric integer)")
    date: str = Field(..., description="Target business date formatted as YYYY-MM-DD")
    amount: float = Field(..., description="Monetary transaction amount (floating-point)")
    category: str = Field(..., description="Domain category classification")

class FileValidationError(BaseModel):
    line_number: int
    byte_position: int
    error_message: str
    raw_content: Optional[str] = None

class FileValidationReport(BaseModel):
    file_path: str
    detected_encoding: str
    newline_style: str  # "CRLF", "LF", "Mixed", "Unknown"
    total_rows: int = 0
    valid_rows: int = 0
    errors: List[FileValidationError] = Field(default_factory=list)

# ==========================================
# 2. Pre-Validation Core Engine
# ==========================================
class CSVValidatorEngine:
    def __init__(self, target_dir: str, delimiter: str = ","):
        self.target_dir = Path(target_dir)
        self.delimiter = delimiter

    def detect_encoding(self, file_path: Path) -> str:
        """
        Inspects file payload heuristics to determine source character set.
        Defaults to CP932 as an enterprise fallback code page.
        """
        try:
            results = from_path(file_path)
            best_match = results.best()
            if best_match and best_match.encoding:
                return best_match.encoding
        except Exception:
            pass
        return "cp932"

    def analyze_newlines(self, binary_content: bytes) -> str:
        """
        Scans un-decoded binary byte sequences to identify newline style and
        detect intra-file mixed carriage-return / line-feed patterns.
        """
        has_crlf = b"\r\n" in binary_content
        cleaned = binary_content.replace(b"\r\n", b"")
        has_lf = b"\n" in cleaned
        has_cr = b"\r" in cleaned and not has_crlf

        if has_crlf and (has_lf or has_cr):
            return "Mixed"
        elif has_crlf:
            return "CRLF"
        elif has_lf or has_cr:
            return "LF"
        return "Unknown"

    def validate_file(self, file_path: Path) -> FileValidationReport:
        print(f"[*] Auditing Target Payload: {file_path}")

        try:
            with open(file_path, "rb") as f:
                binary_data = f.read()
        except Exception as e:
            return FileValidationReport(
                file_path=str(file_path),
                detected_encoding="ERROR",
                newline_style="ERROR",
                errors=[FileValidationError(line_number=0, byte_position=0, error_message=f"I/O Read Failure: {e}")]
            )

        newline_style = self.analyze_newlines(binary_data)
        encoding = self.detect_encoding(file_path)

        report = FileValidationReport(
            file_path=str(file_path),
            detected_encoding=encoding,
            newline_style=newline_style
        )

        try:
            text_content = binary_data.decode(encoding, errors="replace")
        except Exception as e:
            report.errors.append(FileValidationError(
                line_number=0, byte_position=0, error_message=f"Decode Exception ({encoding}): {e}"
            ))
            return report

        lines = text_content.splitlines(keepends=True)
        report.total_rows = len(lines)

        current_byte_pos = 0
        reader = csv.reader(lines, delimiter=self.delimiter)

        header = None
        for idx, row in enumerate(reader, start=1):
            line_str = lines[idx - 1]
            line_bytes_len = len(line_str.encode(encoding, errors="replace"))

            # Extract header schema reference
            if idx == 1:
                header = row
                current_byte_pos += line_bytes_len
                continue

            # Skip empty or whitespace-only records
            if not row or all(not field.strip() for field in row):
                current_byte_pos += line_bytes_len
                continue

            # Verify column parity against defined header contract
            if header and len(row) != len(header):
                report.errors.append(FileValidationError(
                    line_number=idx,
                    byte_position=current_byte_pos,
                    error_message=f"Column Parity Mismatch: Expected {len(header)} fields, parsed {len(row)}",
                    raw_content=",".join(row)
                ))
                current_byte_pos += line_bytes_len
                continue

            try:
                if header:
                    row_dict = dict(zip(header, row))
                else:
                    row_dict = {f"col_{i}": val for i, val in enumerate(row)}

                CSVRowSchema.model_validate(row_dict)
                report.valid_rows += 1
            except ValidationError as ve:
                err_msgs = "; ".join([f"{err['loc']}: {err['msg']}" for err in ve.errors()])
                report.errors.append(FileValidationError(
                    line_number=idx,
                    byte_position=current_byte_pos,
                    error_message=f"Pydantic Contract Violation -> {err_msgs}",
                    raw_content=",".join(row)
                ))
            except Exception as e:
                report.errors.append(FileValidationError(
                    line_number=idx,
                    byte_position=current_byte_pos,
                    error_message=f"Unhandled Deserialization Error: {e}",
                    raw_content=",".join(row)
                ))

            current_byte_pos += line_bytes_len

        return report

    def run(self) -> List[FileValidationReport]:
        reports = []
        csv_files = list(self.target_dir.glob("**/*.csv"))
        if not csv_files:
            print(f"[!] Target scan directory yielded no CSV files: {self.target_dir}")
            return reports

        for file_path in csv_files:
            rep = self.validate_file(file_path)
            reports.append(rep)

        return reports

# ==========================================
# 3. CLI Orchestration & Audit Summary
# ==========================================
def main():
    import argparse
    parser = argparse.ArgumentParser(description="Legacy CSV Ingestion Pre-flight Validator")
    parser.add_argument("--dir", required=True, help="Target directory for recursive file scanning")
    parser.add_argument("--delimiter", default=",", help="Field delimiter character (defaults to comma)")
    parser.add_argument("--json-out", help="Optional output path for structured JSON audit report")

    args = parser.parse_args()

    engine = CSVValidatorEngine(target_dir=args.dir, delimiter=args.delimiter)
    reports = engine.run()

    total_files = len(reports)
    total_errors = sum(len(r.errors) for r in reports)

    print("\n" + "=" * 50)
    print(f" CSV INGESTION AUDIT SUMMARY (Scanned Files: {total_files})")
    print("=" * 50)

    for rep in reports:
        print(f"\nTarget File: {rep.file_path}")
        print(f"  - Inferred Encoding:  {rep.detected_encoding}")
        print(f"  - Line Term. Style:   {rep.newline_style}")
        print(f"  - Total Scanned Rows: {rep.total_rows}")
        print(f"  - Valid Passed Rows:  {rep.valid_rows}")
        print(f"  - Total Error Count:  {len(rep.errors)}")

        if rep.errors:
            print("  [Sample Error Traces (Top 10)]")
            for err in rep.errors[:10]:
                print(f"    -> Line: {err.line_number} | Byte Offset: {err.byte_position} | {err.error_message}")
            if len(rep.errors) > 10:
                print(f"    ... {len(rep.errors) - 10} additional errors truncated")

    if args.json_out:
        try:
            serialized_data = [
                orjson.dumps(r.model_dump(), option=orjson.OPT_INDENT_2 | orjson.OPT_UTC_Z) 
                for r in reports
            ]
            with open(args.json_out, "wb") as f:
                f.write(b"[\n" + b",\n".join(serialized_data) + b"\n]")
            print(f"\n[+] Detailed audit trail written via orjson to: {args.json_out}")
        except Exception as e:
            print(f"[!] JSON report serialization failed: {e}", file=sys.stderr)

    if total_errors > 0:
        print(f"\n[!] Failure: Data quality boundary check detected {total_errors} structural errors.")
        sys.exit(1)
    else:
        print("\n[+] Verification successful: All records satisfy target schema contracts.")
        sys.exit(0)

if __name__ == "__main__":
    main()

[!] Critical Error: Mandatory dependency 'orjson' is missing.
[!] Ensure all required dependencies are installed in your runtime environment:
    pip install orjson charset-normalizer pydantic