"""Structural verification entry point; this module does not start a production server."""
import argparse
import json
import sqlite3
import sys
from datetime import datetime, timezone
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from data_paths import default_db_path
from fleet_dashboard import FleetDashboard, DEFAULT_DB, lease_fixture_report, amount, timestamp
from admin_vault_audit import SovereignAdminVaultAuditor
from licensing_controls import LicenseControl, ClickwrapApp


def create_clickwrap_app(db_path, terms_text, version, *, pepper, authenticate=None,
                         origin='https://unconfigured.invalid', approved=False, approval_reference=None,
                         tenant_symbols=None):
    """Host integration factory. Explicit migration and authenticated TLS host required.

    The existing default command stays a read-only structural check. This factory
    neither installs tables nor starts a listener or authorizes broker execution.
    """
    control=LicenseControl(db_path,terms_text,version,pepper=pepper,approved=approved,
                           approval_reference=approval_reference,tenant_symbols=tenant_symbols)
    return ClickwrapApp(control,authenticate=authenticate,origin=origin)


def evaluate_signal_fixture(signal):
    """Parse requested coordinates, while keeping the existing ingress freeze."""
    result = {'gateway_status':'BLOCKED_INGRESS_FREEZE', 'input_provenance':'USER_SUPPLIED_SIGNAL_FIXTURE',
              'routed_units':'0.0000', 'fill_verified':False, 'broker_orders_submitted':0,
              'live_clearance_granted':False}
    if not isinstance(signal, dict):
        result.update(input_status='INVALID_SIGNAL', validation_error='Structured signal required')
        return result
    try:
        if signal.get('asset_class') != 'CRYPTO' or signal.get('symbol') not in ('BTC/USD','ETH/USD','SOL/USD'):
            raise ValueError('Supported explicit crypto symbol required')
        if signal.get('side') not in ('BUY','SELL'):
            raise ValueError('BUY or SELL side required')
        units, price = amount(signal['units']), amount(signal['price'])
        if min(units,price) <= 0:
            raise ValueError('Positive requested units and price required')
        result.update(asset_class=signal['asset_class'],symbol=signal['symbol'],side=signal['side'],
                      requested_units=format(units,'f'),requested_price=format(price,'f'),
                      requested_notional_assuming_unit_multiplier_1=format(units*price,'f'),
                      price_source_verified=False,account_equity_verified=False,stop_risk_verified=False)
        timestamp(signal['timestamp'])
        result['input_status']='PARSED_UNVERIFIED_FIXTURE'
    except (ValueError, KeyError):
        result.update(input_status='INVALID_OR_INCOMPLETE_SIGNAL',
                      validation_error='Complete valid coordinates and timezone-aware timestamp required')
    return result


def verify_structure(fleet_db=DEFAULT_DB, diary_db=str(default_db_path(ROOT/'foresixa_pure_sandbox.db')), *, include_fixtures=False):
    """Existing registries stay read-only; fixtures use only temporary memory."""
    report = {'verification_mode':'LOCAL_STRUCTURAL_CHECK_ONLY',
              'server_time':datetime.now(timezone.utc).isoformat(), 'server_listening':False,
              'source_provenance':'NEW_VERIFICATION_MODULE_ORIGINAL_SERVER_NOT_LOCATED',
              'billing_executed':False,'collected_revenue_verified':False,
              'broker_orders_submitted':0,'live_clearance_granted':False}
    dashboard = None
    try:
        dashboard = FleetDashboard(fleet_db)
        report['persistent_fleet_registry']=dashboard.generate_summary()
    except (OSError,ValueError,sqlite3.Error):
        report['persistent_fleet_registry']={'status':'REGISTRY_UNAVAILABLE','reason':'Existing registry required'}
    finally:
        if dashboard:
            dashboard.close()
    auditor = None
    try:
        auditor = SovereignAdminVaultAuditor(diary_db)
        private = auditor.read_internal_cognitive_diaries(include_entries=False)
        # Diary text is not combined with any commercial/client feed.
        report['private_diary_summary']={key:private[key] for key in
            ('status','entry_count','tenant_distribution_allowed','directives_applied','learning_effectiveness_verified')}
    except (OSError,sqlite3.Error):
        report['private_diary_summary']={'status':'DIARY_UNAVAILABLE','entry_count':0,
                                         'tenant_distribution_allowed':False,'directives_applied':False}
    finally:
        if auditor:
            auditor.close()
    fleet_ok = report['persistent_fleet_registry']['status'] in ('REGISTRY_EMPTY','FLEET_REPORT_COMPLETE')
    diary_ok = report['private_diary_summary']['status'] in ('NO_DIARY_EVIDENCE','RECORDED_DIARY_TEXT_READ')
    report['structural_status']='CHECKED_NO_OPERATIONAL_CLEARANCE' if fleet_ok and diary_ok else 'MISSING_REQUIRED_TABLE_EVIDENCE'
    if include_fixtures:
        report['isolated_lease_fixture']=lease_fixture_report()
        report['supplied_signal_fixture']=evaluate_signal_fixture({
            'asset_class':'CRYPTO','symbol':'BTC/USD','side':'BUY','units':'2.5',
            'price':'64250','timestamp':'2026-10-04T21:21:00.123456'})
    return report


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--db-path', default=str(DEFAULT_DB))
    parser.add_argument('--diary-db-path', default=str(default_db_path(ROOT/'foresixa_pure_sandbox.db')))
    parser.add_argument('--include-fixtures',action='store_true')
    parser.add_argument('--output')
    args=parser.parse_args()
    output=Path(args.output).resolve() if args.output else None
    if output and (output.exists() or output in (Path(args.db_path).resolve(),Path(args.diary_db_path).resolve())):
        parser.error('Existing output and databases preserved; choose a fresh report path')
    report=verify_structure(args.db_path,args.diary_db_path,include_fixtures=args.include_fixtures)
    if output:
        # A report may name clients; create it privately and never overwrite another file.
        import os
        fd=os.open(output,os.O_WRONLY|os.O_CREAT|os.O_EXCL,0o600)
        with os.fdopen(fd,'w',encoding='utf-8') as stream:
            json.dump(report,stream,indent=2,allow_nan=False)
    print(json.dumps(report,indent=2,allow_nan=False))
    return 0 if report['structural_status']=='CHECKED_NO_OPERATIONAL_CLEARANCE' else 1


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