import hashlib
import json
import uuid

from django.db import migrations, models
import django.db.models.deletion


def _hash(payload):
    raw = json.dumps(
        payload,
        sort_keys=True,
        separators=(",", ":"),
        ensure_ascii=False,
        allow_nan=False,
    )
    return hashlib.sha256(raw.encode("utf-8")).hexdigest()


def _evidence(
    *, session_id, sequence, schema_version, policy_key, policy_version,
    event_type, visibility, club_id, revision, payload
):
    return {
        "session_id": str(session_id),
        "sequence": sequence,
        "schema_version": schema_version,
        "policy_key": policy_key,
        "policy_version": policy_version,
        "event_type": event_type,
        "visibility": visibility,
        "club_id": str(club_id) if club_id else None,
        "revision": revision,
        "payload": payload,
    }


def backfill_stream(apps, schema_editor):
    Session = apps.get_model("matches", "InteractiveMatchSession")
    Checkpoint = apps.get_model("matches", "InteractiveMatchCheckpoint")
    StreamEvent = apps.get_model("matches", "LiveMatchStreamEvent")

    for session in Session.objects.all().iterator():
        sequence = 0
        checkpoints = list(Checkpoint.objects.filter(session_id=session.pk).order_by("segment"))
        for index, checkpoint in enumerate(checkpoints):
            sequence += 1
            is_last = index == len(checkpoints) - 1
            checkpoint_status = (
                session.status
                if is_last and session.status == "COMPLETED"
                else "OPEN"
            )
            payload = {
                "checkpoint_id": str(checkpoint.pk),
                "segment": checkpoint.segment,
                "start_minute": checkpoint.start_minute,
                "end_minute": checkpoint.end_minute,
                "phase": checkpoint.phase,
                "home_score": checkpoint.home_score,
                "away_score": checkpoint.away_score,
                "events": checkpoint.events_payload,
                "tactical_decisions": checkpoint.tactical_decisions_payload,
                "command_sequence": checkpoint.command_sequence,
                "projection_hash": checkpoint.projection_hash,
                "status": checkpoint_status,
                "revision": session.revision,
                "next_advance_at": None,
                "backfilled": True,
            }
            evidence = _evidence(
                session_id=session.pk,
                sequence=sequence,
                schema_version=1,
                policy_key="ftg.match.live_stream.v1",
                policy_version="1.0.0",
                event_type="CHECKPOINT_PUBLISHED",
                visibility="PUBLIC",
                club_id=None,
                revision=session.revision,
                payload=payload,
            )
            StreamEvent.objects.create(
                session_id=session.pk,
                sequence=sequence,
                schema_version=1,
                policy_key="ftg.match.live_stream.v1",
                policy_version="1.0.0",
                event_type="CHECKPOINT_PUBLISHED",
                visibility="PUBLIC",
                revision=session.revision,
                payload=payload,
                event_hash=_hash(evidence),
            )

        if session.status != "PREPARED":
            sequence += 1
            payload = {
                "session_id": str(session.pk),
                "match_id": str(session.match_id),
                "status": session.status,
                "current_segment": session.current_segment,
                "current_minute": session.current_minute,
                "home_score": session.home_score,
                "away_score": session.away_score,
                "next_advance_at": session.next_advance_at.isoformat() if session.next_advance_at else None,
                "backfilled": True,
            }
            evidence = _evidence(
                session_id=session.pk,
                sequence=sequence,
                schema_version=1,
                policy_key="ftg.match.live_stream.v1",
                policy_version="1.0.0",
                event_type="STATE_SNAPSHOT",
                visibility="PUBLIC",
                club_id=None,
                revision=session.revision,
                payload=payload,
            )
            StreamEvent.objects.create(
                session_id=session.pk,
                sequence=sequence,
                schema_version=1,
                policy_key="ftg.match.live_stream.v1",
                policy_version="1.0.0",
                event_type="STATE_SNAPSHOT",
                visibility="PUBLIC",
                revision=session.revision,
                payload=payload,
                event_hash=_hash(evidence),
            )

        if session.status in {"COMPLETED", "ABORTED"}:
            sequence += 1
            if session.status == "COMPLETED":
                event_type = "MATCH_COMPLETED"
                payload = {
                    "session_id": str(session.pk),
                    "match_id": str(session.match_id),
                    "status": session.status,
                    "current_segment": session.current_segment,
                    "current_minute": session.current_minute,
                    "home_score": session.home_score,
                    "away_score": session.away_score,
                    "completed_at": session.completed_at.isoformat() if session.completed_at else None,
                    "backfilled": True,
                }
            else:
                event_type = "MATCH_ABORTED"
                payload = {
                    "session_id": str(session.pk),
                    "match_id": str(session.match_id),
                    "status": session.status,
                    "current_minute": session.current_minute,
                    "home_score": session.home_score,
                    "away_score": session.away_score,
                    "aborted_at": session.aborted_at.isoformat() if session.aborted_at else None,
                    "backfilled": True,
                }
            evidence = _evidence(
                session_id=session.pk,
                sequence=sequence,
                schema_version=1,
                policy_key="ftg.match.live_stream.v1",
                policy_version="1.0.0",
                event_type=event_type,
                visibility="PUBLIC",
                club_id=None,
                revision=session.revision,
                payload=payload,
            )
            StreamEvent.objects.create(
                session_id=session.pk,
                sequence=sequence,
                schema_version=1,
                policy_key="ftg.match.live_stream.v1",
                policy_version="1.0.0",
                event_type=event_type,
                visibility="PUBLIC",
                revision=session.revision,
                payload=payload,
                event_hash=_hash(evidence),
            )
        Session.objects.filter(pk=session.pk).update(stream_sequence=sequence)


def noop_reverse(apps, schema_editor):
    pass


class Migration(migrations.Migration):
    dependencies = [
        ("matches", "0013_interactive_match_runner_live_command_api"),
    ]

    operations = [
        migrations.AddField(
            model_name="interactivematchsession",
            name="stream_sequence",
            field=models.PositiveIntegerField(default=0),
        ),
        migrations.CreateModel(
            name="LiveMatchStreamEvent",
            fields=[
                ("id", models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
                ("sequence", models.PositiveIntegerField()),
                ("schema_version", models.PositiveSmallIntegerField(default=1)),
                ("policy_key", models.CharField(default="ftg.match.live_stream.v1", max_length=100)),
                ("policy_version", models.CharField(default="1.0.0", max_length=30)),
                ("event_type", models.CharField(choices=[
                    ("SESSION_OPENED", "Interactive session opened"),
                    ("STATE_SNAPSHOT", "Backfilled/current stream state snapshot"),
                    ("COMMAND_ACCEPTED", "Manager command accepted"),
                    ("CHECKPOINT_PUBLISHED", "Checkpoint published"),
                    ("MATCH_COMPLETED", "Interactive match completed"),
                    ("MATCH_ABORTED", "Interactive match aborted"),
                ], max_length=32)),
                ("visibility", models.CharField(choices=[
                    ("PUBLIC", "Visible to authenticated spectators"),
                    ("CLUB", "Visible to one participating club"),
                    ("STAFF", "Visible only to staff"),
                ], default="PUBLIC", max_length=12)),
                ("revision", models.PositiveIntegerField(default=0)),
                ("payload", models.JSONField(default=dict)),
                ("event_hash", models.CharField(max_length=64)),
                ("created_at", models.DateTimeField(auto_now_add=True)),
                ("club", models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name="live_stream_events", to="clubs.club")),
                ("session", models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name="stream_events", to="matches.interactivematchsession")),
            ],
            options={
                "ordering": ["session_id", "sequence"],
                "indexes": [
                    models.Index(fields=["session", "sequence"], name="live_stream_seq_idx"),
                    models.Index(fields=["session", "visibility", "sequence"], name="live_stream_vis_seq_idx"),
                ],
                "constraints": [
                    models.UniqueConstraint(fields=("session", "sequence"), name="uq_live_stream_sequence"),
                    models.CheckConstraint(condition=models.Q(sequence__gte=1), name="live_stream_sequence_gte1"),
                    models.CheckConstraint(condition=models.Q(schema_version__gte=1), name="live_stream_schema_gte1"),
                    models.CheckConstraint(condition=models.Q(event_type__in=["SESSION_OPENED", "STATE_SNAPSHOT", "COMMAND_ACCEPTED", "CHECKPOINT_PUBLISHED", "MATCH_COMPLETED", "MATCH_ABORTED"]), name="live_stream_valid_type"),
                    models.CheckConstraint(condition=models.Q(visibility__in=["PUBLIC", "CLUB", "STAFF"]), name="live_stream_valid_visibility"),
                    models.CheckConstraint(condition=(models.Q(visibility="CLUB", club__isnull=False) | models.Q(visibility__in=["PUBLIC", "STAFF"], club__isnull=True)), name="live_stream_visibility_club_consistent"),
                    models.CheckConstraint(condition=~models.Q(event_hash=""), name="live_stream_hash_nonempty"),
                ],
            },
        ),
        migrations.RunPython(backfill_stream, noop_reverse),
    ]
