"""Read-only recorded-ledger diagnostics. Never grants production clearance."""
from data_paths import default_db_path
import argparse
import json
import sqlite3
import tempfile
from datetime import datetime,timezone
from decimal import Decimal,InvalidOperation
from pathlib import Path


class ProductionLiveCycleAuditor:
    def __init__(self,db_filepath=str(default_db_path('foresixa_pure_sandbox.db'))):
        self.path=Path(db_filepath).resolve()
        self.conn=None

    def execute_system_wide_audit(self):
        report={'status':'EVIDENCE_UNAVAILABLE','observed_at':datetime.now(timezone.utc).isoformat(),
                'scope':'RECORDED_WORKPAPER_DIAGNOSTICS_ONLY','ledger_modified':False,
                'live_executions_verified':False,'automatic_parameter_updates_verified':False,
                'live_clearance_granted':False,'verified_trial_sessions':None}
        if not self.path.is_file():
            report['reason']='Existing ledger not found';return report
        try:
            self.conn=sqlite3.connect(self.path.as_uri()+'?mode=ro',uri=True)
            self.conn.row_factory=sqlite3.Row
            self.conn.execute('PRAGMA query_only=ON');self.conn.execute('BEGIN')
            if self.conn.execute('PRAGMA quick_check').fetchone()[0]!='ok':raise ValueError('Database integrity check failed')
            cols={r[1] for r in self.conn.execute('PRAGMA table_info(form_8949_ledger)')}
            needed={'net_gain_or_loss','equity_symbol','order_id'}
            if not needed<=cols:
                report['reason']='Required disposition table or columns missing';return report
            wins=losses=flat=0;profits=Decimal(0);loss_amount=Decimal(0)
            for row in self.conn.execute('SELECT net_gain_or_loss FROM form_8949_ledger'):
                value=Decimal(str(row['net_gain_or_loss']))
                if not value.is_finite():raise ValueError('Invalid recorded PnL')
                if value>0:wins+=1;profits+=value
                elif value<0:losses+=1;loss_amount-=value
                else:flat+=1
            total=wins+losses+flat
            factor=profits/loss_amount if loss_amount>0 else None
            intelligence={'status':'TABLE_UNAVAILABLE','recorded_cross_references':None,'recorded_new_knowledge_flags':None,
                          'parameter_application_verified':False}
            crosscols={r[1] for r in self.conn.execute('PRAGMA table_info(pattern_cross_references)')}
            if 'is_classified_as_new_knowledge' in crosscols:
                r=self.conn.execute('SELECT COUNT(*),SUM(CASE WHEN is_classified_as_new_knowledge=1 THEN 1 ELSE 0 END),SUM(CASE WHEN is_classified_as_new_knowledge NOT IN (0,1) OR is_classified_as_new_knowledge IS NULL THEN 1 ELSE 0 END) FROM pattern_cross_references').fetchone()
                intelligence.update(status='RECORDED_FLAGS_READ' if not r[2] else 'INVALID_RECORDED_FLAGS',
                                    recorded_cross_references=r[0],recorded_new_knowledge_flags=r[1] or 0)
            report.update(status='RECORDED_DIAGNOSTICS_READ' if total else 'NO_DISPOSITION_EVIDENCE',
                          total_trades=total,winning_trades=wins,losing_trades=losses,breakeven_trades=flat,
                          win_rate_pct=str(Decimal(wins)/total*100) if total else None,
                          gross_recorded_profits=str(profits),gross_recorded_losses=str(loss_amount),
                          profit_factor=str(factor) if factor is not None else None,
                          profit_factor_status='FINITE_RATIO' if factor is not None else ('UNBOUNDED_NO_RECORDED_LOSSES' if profits else 'UNDEFINED_NO_PROFITS_OR_LOSSES'),
                          diagnostic_profit_factor_threshold_met=(factor>=Decimal('1.5')) if factor is not None else None,
                          intelligence=intelligence,production_decision='BLOCKED_NO_PRODUCTION_AUTHORITY',
                          evidence_required=['Broker reconciliation and provenance','100 complete scheduled eligible sessions',
                                             'Rolling research score >=97/100 with no hard risk veto',
                                             'Separately authorized legal, security and operational release'])
            return report
        except (sqlite3.Error,ValueError,InvalidOperation):
            report['reason']='Ledger could not be validated; no fallback metrics used';return report
        finally:self.close()

    def close(self):
        if self.conn:self.conn.close();self.conn=None


def demo_report():
    with tempfile.TemporaryDirectory(prefix='foresixa-cycle-fixture-') as directory:
        path=Path(directory)/'synthetic.db'
        with sqlite3.connect(path) as c:
            c.execute('CREATE TABLE form_8949_ledger(order_id INTEGER,equity_symbol TEXT,net_gain_or_loss TEXT)')
            c.executemany('INSERT INTO form_8949_ledger VALUES(?,?,?)',[(1,'BTC/USD','200'),(2,'BTC/USD','200'),(3,'/MES','100'),(4,'AAPL','-110'),(5,'NVDA','240')])
        result=ProductionLiveCycleAuditor(path).execute_system_wide_audit()
        result['provenance']='USER_SUPPLIED_SYNTHETIC_FIVE_DISPOSITION_FIXTURE'
        result['verified_trial_sessions']=0
        return result


def main():
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument('--db-path',default=str(default_db_path('foresixa_pure_sandbox.db')));p.add_argument('--demo',action='store_true')
    args=p.parse_args()
    if args.demo and args.db_path!=str(default_db_path('foresixa_pure_sandbox.db')):p.error('Demo never reads an actual ledger; omit --db-path')
    result=demo_report() if args.demo else ProductionLiveCycleAuditor(args.db_path).execute_system_wide_audit()
    print(json.dumps(result,indent=2,allow_nan=False))
    return 0 if result['status']=='RECORDED_DIAGNOSTICS_READ' else 1


if __name__=='__main__':raise SystemExit(main())