"""Reproduce one Codex-authored local workflow, not an independent model benchmark.

Creates and reopens XLSX, PPTX and PDF outputs, tests one revision per format,
and emits dated evidence only after checks actually finish. No API or network calls.
The downloadable script works beside fixtures.json with requirements installed.
"""
import argparse
import hashlib
import importlib.metadata
import json
import platform
import sys
from datetime import datetime, timezone
from pathlib import Path

# Optional site-scoped dependencies; no changes to the global Python environment.
local_libs = Path(__file__).resolve().parents[2] / '_ops' / 'file-test-libs'
if local_libs.is_dir():
    sys.path.insert(0, str(local_libs))
import openpyxl
from openpyxl.styles import Font, PatternFill
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor
import pymupdf

parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--output', required=True, type=Path)
args = parser.parse_args()
out = args.output.resolve()
out.mkdir(parents=True, exist_ok=True)
fixture_path = Path(__file__).with_name('fixtures.json')
fixture = json.loads(fixture_path.read_text(encoding='utf-8'))
checks = []

def check(name, actual, expected):
    if actual != expected:
        raise AssertionError(f'{name}: {actual!r} != {expected!r}')
    checks.append(name)

def total(rows):
    return sum(row[1] * row[2] for row in rows)

def check_sheet(sheet, expected_quantity, expected_total):
    assert sheet['B3'].value == expected_quantity
    rows = []
    for index in range(2, 5):
        assert sheet[f'D{index}'].value == f'=B{index}*C{index}'
        rows.append([sheet[f'A{index}'].value, sheet[f'B{index}'].value, sheet[f'C{index}'].value])
    assert sheet['D5'].value == '=SUM(D2:D4)'
    assert total(rows) == expected_total

# Spreadsheet: formulas are preserved, not executed by openpyxl.
book = openpyxl.Workbook()
sheet = book.active
sheet.title = 'Order'
sheet.append(['Item', 'Quantity', 'Unit price', 'Line total'])
for index, row in enumerate(fixture['items'], 2):
    sheet.append(row + [f'=B{index}*C{index}'])
sheet.append(['Total', None, None, '=SUM(D2:D4)'])
for cell in sheet[1]:
    cell.fill = PatternFill('solid', fgColor='111A2C')
    cell.font = Font(color='FFFFFF', bold=True)
for column in ['A', 'B', 'C', 'D']:
    sheet.column_dimensions[column].width = 22
sheet.freeze_panes = 'A2'
for row in sheet.iter_rows(min_row=2, max_row=5, min_col=3, max_col=4):
    for cell in row:
        cell.number_format = '0.00'
notes = book.create_sheet('Read me')
notes.append(['Synthetic example; amounts are invented.'])
notes.append(['Formula cells are not evaluated by this script. Open in a spreadsheet app and recalculate.'])
notes.append(['Arithmetic expected total', fixture['expected_total']])
book.save(out / 'order.xlsx')
reopened = openpyxl.load_workbook(out / 'order.xlsx')
check_sheet(reopened['Order'], 3, fixture['expected_total'])
check('Workbook sheets survive save and reopen', reopened.sheetnames, ['Order', 'Read me'])
reopened['Order']['B3'] = fixture['revised_folders_quantity']
reopened['Read me']['B3'] = fixture['expected_revised_total']
reopened.save(out / 'order-revised.xlsx')
revised_book = openpyxl.load_workbook(out / 'order-revised.xlsx')
check_sheet(revised_book['Order'], 5, fixture['expected_revised_total'])
check('Spreadsheet revision retains line formula', revised_book['Order']['D3'].value, '=B3*C3')
check('Spreadsheet independent arithmetic after revision', total([[revised_book['Order'].cell(i, j).value for j in range(1, 4)] for i in range(2, 5)]), 155)
revised_book['Order']['D3'] = '=B3+C3'
try:
    check_sheet(revised_book['Order'], 5, 155)
except AssertionError:
    checks.append('Negative control: incorrect spreadsheet formula rejected')
else:
    raise AssertionError('The formula negative control was not rejected')
cached_book = openpyxl.load_workbook(out / 'order.xlsx', data_only=True)
check('Limit observed: no evaluated formula cache', cached_book['Order']['D5'].value, None)

# Presentation: check text and targeted revision, not PowerPoint rendering.
deck = Presentation()
deck.slide_width = Inches(12)
deck.slide_height = Inches(6.75)
bodies = ['Synthetic fixture / three items / no customer information.', 'Expected order total: 115.00\nThis is invented test data, not a business forecast.', fixture['original_next_step']]
for index, (title, body) in enumerate(zip(fixture['slide_titles'], bodies)):
    slide = deck.slides.add_slide(deck.slide_layouts[6])
    slide.background.fill.solid()
    slide.background.fill.fore_color.rgb = RGBColor.from_string('F1EFE8')
    for text, y, size in [(f'FILE WORKFLOW LAB / {index + 1:02}', .55, 13), (title, 1.5, 32), (body, 3, 23)]:
        box = slide.shapes.add_textbox(Inches(.7), Inches(y), Inches(10.5), Inches(1.7))
        box.text_frame.text = text
        for paragraph in box.text_frame.paragraphs:
            paragraph.font.size = Pt(size)
            paragraph.font.color.rgb = RGBColor.from_string('111A2C')
deck.save(out / 'brief.pptx')

def slide_text(presentation):
    return [[shape.text for shape in slide.shapes if shape.has_text_frame] for slide in presentation.slides]

original_deck = Presentation(out / 'brief.pptx')
before = slide_text(original_deck)
check('Presentation slide count', len(original_deck.slides), 3)
check('Presentation titles survive reopen', [texts[1] for texts in before], fixture['slide_titles'])
original_deck.slides[2].shapes[2].text_frame.paragraphs[0].runs[0].text = fixture['revised_next_step']
original_deck.save(out / 'brief-revised.pptx')
after = slide_text(Presentation(out / 'brief-revised.pptx'))
check('Presentation revision leaves slides 1 and 2 unchanged', after[:2], before[:2])
check('Presentation requested replacement', after[2][2], fixture['revised_next_step'])
check('Presentation unaffected title', after[2][1], before[2][1])

# PDF: create two pages, reopen, extract text, revise one page, render PNGs.
def make_pdf(path, status):
    document = pymupdf.open()
    content = [
        ['OFFICE ORDER / SYNTHETIC EXAMPLE', 'Three rows. One checkable total.', 'Notebooks: 2 x 12.50 = 25.00', 'Folders: 3 x 20.00 = 60.00', 'Markers: 4 x 7.50 = 30.00', 'Total: 115.00'],
        ['REVIEW NOTES', status, 'Fixture: synthetic-office-v1', 'No customer data. No performance benchmark.', 'Check totals, layout and the requested revision before sharing.']
    ]
    for lines in content:
        page = document.new_page(width=595, height=842)
        page.draw_rect(page.rect, color=None, fill=(.945, .937, .910))
        for index, line in enumerate(lines):
            page.insert_text((45, 70 + 48 * index), line, fontsize=16 if index < 2 else 12, color=(.067, .102, .173))
    document.save(path)
    document.close()

make_pdf(out / 'order.pdf', fixture['pdf_original_status'])
make_pdf(out / 'order-revised.pdf', fixture['pdf_revised_status'])
with pymupdf.open(out / 'order.pdf') as original, pymupdf.open(out / 'order-revised.pdf') as revised:
    check('PDF page count', len(original), 2)
    check('PDF revised page count', len(revised), 2)
    check('PDF total is extractable', 'Total: 115.00' in original[0].get_text(), True)
    check('PDF revision leaves page 1 unchanged', original[0].get_text(), revised[0].get_text())
    check('PDF replacement is extractable', fixture['pdf_revised_status'] in revised[1].get_text(), True)
    check('PDF prior status absent from revised page', fixture['pdf_original_status'] in revised[1].get_text(), False)
    for index, page in enumerate(revised):
        page.get_pixmap(matrix=pymupdf.Matrix(1, 1)).save(out / f'pdf-page-{index + 1}.png')

outputs = []
for name in ['order.xlsx', 'order-revised.xlsx', 'brief.pptx', 'brief-revised.pptx', 'order.pdf', 'order-revised.pdf', 'pdf-page-1.png', 'pdf-page-2.png']:
    file = out / name
    outputs.append({'name': name, 'bytes': file.stat().st_size, 'sha256': hashlib.sha256(file.read_bytes()).hexdigest()})
report = {
    'schema': 1, 'observed_at': datetime.now(timezone.utc).isoformat(timespec='milliseconds'),
    'status': 'pass', 'surface': 'Codex-assisted local Python workflow on Windows',
    'model': 'Not independently recorded; no model-level performance claim',
    'method': 'One authored example and one targeted revision per format; automated structural/content checks. The same Codex session authored and checked the workflow; no independent human review.',
    'fixture': fixture['id'], 'fixture_sha256': hashlib.sha256(fixture_path.read_bytes()).hexdigest(),
    'script_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
    'environment': {'python': platform.python_version(), 'platform': platform.system(), 'libraries': {name: importlib.metadata.version(name) for name in ['openpyxl', 'python-pptx', 'PyMuPDF']}},
    'checks': checks, 'outputs': outputs,
    'limits': ['No ChatGPT web or desktop UI was tested.', 'No Excel or PowerPoint visual rendering was tested.', 'Spreadsheet formulas were inspected and expected values calculated separately; Excel recalculation was not tested.', 'The workbook formula cache is empty until a compatible spreadsheet engine recalculates it.', 'PDF rendering and text extraction do not prove accessibility or arbitrary-document fidelity.', 'One scripted example is not a model benchmark or a success-rate estimate.']
}
(out / 'report.json').write_text(json.dumps(report, indent=2) + '\n', encoding='utf-8')
print(json.dumps({'status': report['status'], 'checks': len(checks), 'observed_at': report['observed_at'], 'outputs': len(outputs)}))