"""Local administrator-only read of recorded diaries, without applying directives."""
from data_paths import default_db_path
import argparse
import json
import sqlite3
from datetime import datetime, timezone
from pathlib import Path

ROOT = Path(__file__).resolve().parent


class SovereignAdminVaultAuditor:
    def __init__(self, db_filepath=str(default_db_path(ROOT / 'foresixa_pure_sandbox.db'))):
        path = Path(db_filepath).resolve()
        if not path.is_file():
            raise FileNotFoundError('Existing diary ledger required; no file created')
        self.conn = sqlite3.connect(path.as_uri() + '?mode=ro', uri=True, timeout=1)
        self.conn.row_factory = sqlite3.Row
        self.conn.execute('PRAGMA query_only=ON')

    def read_internal_cognitive_diaries(self, *, include_entries=True):
        report = {'status': 'DIARY_UNAVAILABLE', 'reported_at': datetime.now(timezone.utc).isoformat(),
                  'audience': 'LOCAL_ADMINISTRATOR_ONLY', 'tenant_distribution_allowed': False,
                  'application_authentication_provided': False, 'entry_count': 0,
                  'entries': [], 'directives_applied': False, 'learning_effectiveness_verified': False,
                  'live_clearance_granted': False}
        try:
            self.conn.execute('BEGIN')
            if [row[0] for row in self.conn.execute('PRAGMA quick_check')] != ['ok']:
                raise ValueError('Structural check failed')
            required = {'audit_id','trading_day_timestamp','missed_pattern_signature',
                        'tactical_error_analysis','self_correction_directive','learned_at'}
            columns = {row[1] for row in self.conn.execute('PRAGMA table_info(cognitive_post_mortems)')}
            if not required <= columns:
                report['reason'] = 'Missing or incompatible cognitive_post_mortems table'
                return report
            rows = self.conn.execute('''SELECT audit_id, trading_day_timestamp,
                missed_pattern_signature, tactical_error_analysis, self_correction_directive,
                learned_at FROM cognitive_post_mortems ORDER BY learned_at DESC, audit_id DESC''').fetchall()
            report.update(status='RECORDED_DIARY_TEXT_READ' if rows else 'NO_DIARY_EVIDENCE',
                          entry_count=len(rows),
                          ordering='learned_at as stored, descending; not verified exchange chronology',
                          evidence_status='UNVERIFIED_RECORDED_TEXT')
            if include_entries:
                report['entries'] = [dict(row) for row in rows]
            return report
        except (ValueError, sqlite3.Error):
            report['reason'] = 'Diary ledger unreadable; no conclusions or clearance drawn'
            return report
        finally:
            self.conn.rollback()

    def close(self):
        self.conn.close()


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--db-path', default=str(default_db_path(ROOT / 'foresixa_pure_sandbox.db')))
    parser.add_argument('--summary-only', action='store_true')
    args = parser.parse_args()
    auditor = None
    try:
        auditor = SovereignAdminVaultAuditor(args.db_path)
        report = auditor.read_internal_cognitive_diaries(include_entries=not args.summary_only)
        print(json.dumps(report, indent=2, allow_nan=False))
        return 1 if report['status'] == 'DIARY_UNAVAILABLE' else 0
    except (OSError, sqlite3.Error):
        print(json.dumps({'status':'DIARY_UNAVAILABLE','reason':'Existing readable diary ledger required',
                          'live_clearance_granted':False}))
        return 1
    finally:
        if auditor:
            auditor.close()


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