"""Visual-reference assessments never mutate classes/masks or qualify sources."""
from contextlib import closing
from copy import deepcopy
from http.server import ThreadingHTTPServer
import json
from pathlib import Path
import threading
from urllib.error import HTTPError
from urllib.request import Request, urlopen

import pytest

from pallet.cluster_targets import digest
from pallet.mask_anomaly_review import Application, Handler, Store, ReviewError, FALSE_FLAGS, sha
from pallet.pose_review_geometry import canonical


@pytest.fixture
def app(tmp_path):
    root = tmp_path/'package'; root.mkdir()
    classes, refs = [], {}
    for cls in range(1, 23):
        keys = [f'{cls:022x}{j:02x}' for j in (0, 1)]
        classes.append(dict(class_id=cls, reference_keys=keys))
        refs.update({k:dict(target_key=k, class_id=cls) for k in keys})
    key = classes[0]['reference_keys'][0]
    target = dict(target_key=key, class_id=1, vertices=4, polygon=[[0,0],[2,0],[2,2],[0,2]],
        formal_split='test', source_payload_sha256='original-event', source_polygon_sha256='original-polygon',
        same_class_reference_keys=classes[0]['reference_keys'][1:])
    catalog = dict(classes=classes, references=refs, targets={key:target}, queue=[key])
    (root/'catalog.json').write_bytes(canonical(catalog))
    (root/'index.html').write_text('<h1>22类视觉图卡</h1>')
    (root/'manifest.json').write_bytes(canonical(dict(schema='human_anomaly_review_package_v1', automatic_label_application=False,
        target_count=1, current_model_anomalies=1, catalog_sha256=digest(root/'catalog.json'), public_assets={'index.html':digest(root/'index.html')})))
    return Application(root, tmp_path/'isolated-decisions', 'test-key-never-production-0123456789')


def payload(app):
    key = app.catalog['queue'][0]; t = app.target(key)
    return dict(expected_revision=0, reviewer='测试', note='', disposition='reviewed', class_decision='keep',
        mask_decision='valid_vertex_difference', view_decision='different_view_same_class', reasons=['view_variant'],
        suggested_class_id=None, reference_keys_viewed=t['target']['same_class_reference_keys'],
        package_sha256=t['package_sha256'], subject_sha256=t['subject_sha256'])


def test_all22_class_cards_and_no_self_reference(app):
    assert len(app.classes) == 22
    key = app.catalog['queue'][0]
    assert key not in app.targets[key]['same_class_reference_keys']


@pytest.mark.parametrize('flag', FALSE_FLAGS)
def test_saved_assessment_cannot_promote_any_eligibility_or_apply_labels(app, flag):
    data = payload(app); data[flag] = True; key = app.catalog['queue'][0]; original = deepcopy(app.catalog)
    saved = app.save(key, data)
    assert all(saved[f] is False for f in FALSE_FLAGS) and saved['source_formal_split'] == 'test'
    assert saved['original_class_id'] == 1 and saved['event_kind'] == 'human_mask_anomaly_assessment_not_applied'
    assert app.catalog == original and saved['mask_decision'] == 'valid_vertex_difference'


def test_change_class_needs_images_and_reason_and_is_only_proposal(app):
    key = app.catalog['queue'][0]; data = payload(app)
    data.update(class_decision='propose_change', suggested_class_id=2)
    with pytest.raises(ReviewError, match='依据'):
        app.save(key, data)
    data['note'] = '实际面结构需对照，而非按最近邻改类'
    with pytest.raises(ReviewError, match='参考图'):
        app.save(key, data)
    data['reference_keys_viewed'] += app.classes[1]['reference_keys']
    value = app.save(key, data)
    assert value['suggested_class_id'] == 2 and app.targets[key]['class_id'] == 1


@pytest.mark.parametrize('updates', [dict(class_decision='bad'), dict(mask_decision='bad'), dict(view_decision='bad'),
    dict(disposition='bad'), dict(expected_revision=-1), dict(expected_revision=True), dict(reviewer=''),
    dict(note='x'*2001), dict(reasons=['no_issue','boundary']), dict(reasons=[{}]), dict(reasons=['fake']),
    dict(reference_keys_viewed=['foreign']), dict(suggested_class_id=2), dict(reference_keys_viewed=[]),
    dict(class_decision='propose_change', suggested_class_id=1), dict(class_decision='propose_change', suggested_class_id=True)])
def test_invalid_decisions_do_not_append_events(app, updates):
    key = app.catalog['queue'][0]; data = payload(app); data.update(updates)
    with pytest.raises(ReviewError):
        app.save(key, data)
    assert app.store.history(key) == []


def test_uncertainty_and_defer_do_not_require_a_guessed_class_or_images(app):
    data = payload(app); data.update(disposition='deferred', class_decision='uncertain', mask_decision='uncertain',
        view_decision='uncertain', reference_keys_viewed=[])
    assert app.save(app.catalog['queue'][0], data)['disposition'] == 'deferred'


def test_stale_version_and_foreign_source_are_rejected_without_extra_events(app):
    key = app.catalog['queue'][0]; data = payload(app); first = app.save(key, data)
    for d in (data, dict(data, package_sha256='wrong'), dict(data, subject_sha256='wrong')):
        with pytest.raises(ReviewError) as error:
            app.save(key, d)
        assert error.value.status == 409
    with pytest.raises(ReviewError) as error:
        app.save('f'*24, data)
    assert error.value.status == 404 and app.store.history(key) == [first]


def test_history_restore_appends_new_revision_and_preserves_old_raw_events(app):
    key = app.catalog['queue'][0]; data = payload(app); first = app.save(key, data)
    with closing(app.store.connect()) as db:
        raw = db.execute('SELECT payload FROM events WHERE revision=1').fetchone()[0]
    app.save(key, dict(data, expected_revision=1, mask_decision='needs_redraw'))
    third = app.save(key, dict(data, expected_revision=2, restored_from_revision=1))
    assert third['revision'] == 3 and third['restored_from_revision'] == 1
    assert app.store.history(key)[-1] == first
    with closing(app.store.connect()) as db:
        assert db.execute('SELECT payload FROM events WHERE revision=1').fetchone()[0] == raw
    with pytest.raises(ReviewError):
        app.save(key, dict(data, expected_revision=3, restored_from_revision=100))


def test_store_cannot_rebind_or_use_protected_paths(app, tmp_path):
    with pytest.raises(ValueError, match='new review store'):
        Store(app.store.path.parent, 'another-package')
    from pallet.mask_anomaly_review import PROJECT
    for name in ('pallet', 'configs', 'outputs/pallet_mask_gallery_reviews_v1', 'outputs/pallet_mask_dataset_update_v1'):
        with pytest.raises(ValueError, match='isolated'):
            Store(PROJECT/name, 'unsafe')


@pytest.fixture
def http(app):
    server = ThreadingHTTPServer(('127.0.0.1', 0), Handler); server.app = app
    worker = threading.Thread(target=server.serve_forever, daemon=True); worker.start()
    base = f'http://127.0.0.1:{server.server_port}'
    def request(path, data=None, cookie=None, method=None, extra=None):
        headers = dict(extra or {})
        if cookie:
            headers['Cookie'] = cookie
        if data is not None:
            headers.update({'Content-Type':'application/json','X-Review-Request':'1'})
        req = Request(base+path, data=canonical(data) if data is not None else None, headers=headers, method=method)
        try:
            response = urlopen(req, timeout=5)
        except HTTPError as error:
            response = error
        with response:
            return response.status, dict(response.headers), response.read()
    yield request
    server.shutdown(); server.server_close(); worker.join(timeout=5)


def test_http_login_csrf_private_paths_and_readonly_assets(app, http):
    assert http('/')[0] == 200 and http('/healthz')[0] == 200
    assert http('/api/catalog')[0] == 401
    assert http('/api/login', {'key':'wrong'})[0] == 401
    assert http('/api/login', {'key':app.key}, extra={'Origin':'https://evil.example'})[0] == 403
    code, headers, raw = http('/api/login', {'key':app.key}, extra={'X-Forwarded-Proto':'https'})
    cookie = headers['Set-Cookie'].split(';')[0]
    assert code == 200 and 'HttpOnly' in headers['Set-Cookie'] and '; Secure' in headers['Set-Cookie']
    assert 'script-src \'self\'' in headers['Content-Security-Policy']
    assert http('/api/catalog', cookie=cookie)[0] == 200
    for name in ('manifest.json','catalog.json','reviews.sqlite3','access_key.txt','../configs/active_mask_gallery.json','%2e%2e/reviews.sqlite3'):
        assert http('/'+name, cookie=cookie)[0] == 404
    for method in ('PUT','DELETE','PATCH','TRACE','OPTIONS'):
        assert http('/', method=method, cookie=cookie)[0] == 405
    key = app.catalog['queue'][0]
    assert http('/api/reviews/'+key, payload(app), cookie=cookie, extra={'Origin':'https://evil.example'})[0] == 403
    assert http('/api/reviews/'+key, payload(app), cookie=cookie)[0] == 200
    assert http('/api/reviews/'+key, payload(app), cookie=cookie)[0] == 409
    code, _, raw = http('/api/export/reviews.json', cookie=cookie)
    assert code == 200 and json.loads(raw)['labels_applied'] is False
    assert len(app.store.history(key)) == 1


def test_http_frozen_asset_modification_fails_closed(app, http):
    (app.root/'index.html').write_text('changed unexpectedly')
    assert http('/')[0] == 503


def test_ui_has_all_class_atlas_drafts_failure_guards_and_separate_decisions():
    root = Path(__file__).resolve().parents[1]/'pallet/assets/anomaly_review'
    js = (root/'app.js').read_text(); html = (root/'index.html').read_text()
    for text in ('mask-anomaly-assessment-v1:', 'if(explicitSave||dirty)await save(disposition);if(next)await load(next)',
        'restored_from_revision', 'undoStep', '版本冲突', 'class_decision', 'mask_decision', 'view_decision'):
        assert text in js
    for text in ('22类', '不能按多数点数'):
        assert text in (html+js+(Path(__file__).resolve().parents[1]/'scripts/build_mask_anomaly_human_review.py').read_text())
