generate-reports.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HTML report generated: deepseek-r1-1.56.html\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from typing import Dict, Any, List, Tuple\n",
    "\n",
    "###############################################################################\n",
    "# Helpers to parse phases (like \"S1901M\") into a sorted, friendly label\n",
    "###############################################################################\n",
    "\n",
    "\"\"\"\n",
    "Results JSON structure:\n",
    "\n",
    "json_skeleton = {\n",
    "    \"game_id\": \"\",\n",
    "    \"env_state\": {\n",
    "        \"timestamp\": 0,\n",
    "        \"zobrist_hash\": \"\",\n",
    "        \"note\": \"\",\n",
    "        \"name\": \"\",\n",
    "        \"units\": {\n",
    "            \"AUSTRIA\": [],\n",
    "            \"ENGLAND\": [],\n",
    "            \"FRANCE\": [],\n",
    "            \"GERMANY\": [],\n",
    "            \"ITALY\": [],\n",
    "            \"RUSSIA\": [],\n",
    "            \"TURKEY\": []\n",
    "        },\n",
    "        \"retreats\": {\n",
    "            \"AUSTRIA\": {},\n",
    "            \"ENGLAND\": {},\n",
    "            \"FRANCE\": {},\n",
    "            \"GERMANY\": {},\n",
    "            \"ITALY\": {},\n",
    "            \"RUSSIA\": {},\n",
    "            \"TURKEY\": {}\n",
    "        },\n",
    "        \"centers\": {\n",
    "            \"AUSTRIA\": [],\n",
    "            \"ENGLAND\": [],\n",
    "            \"FRANCE\": [],\n",
    "            \"GERMANY\": [],\n",
    "            \"ITALY\": [],\n",
    "            \"RUSSIA\": [],\n",
    "            \"TURKEY\": []\n",
    "        },\n",
    "        \"homes\": {\n",
    "            \"AUSTRIA\": [],\n",
    "            \"ENGLAND\": [],\n",
    "            \"FRANCE\": [],\n",
    "            \"GERMANY\": [],\n",
    "            \"ITALY\": [],\n",
    "            \"RUSSIA\": [],\n",
    "            \"TURKEY\": []\n",
    "        },\n",
    "        \"influence\": {\n",
    "            \"AUSTRIA\": [],\n",
    "            \"ENGLAND\": [],\n",
    "            \"FRANCE\": [],\n",
    "            \"GERMANY\": [],\n",
    "            \"ITALY\": [],\n",
    "            \"RUSSIA\": [],\n",
    "            \"TURKEY\": []\n",
    "        },\n",
    "        \"civil_disorder\": {\n",
    "            \"AUSTRIA\": 0,\n",
    "            \"ENGLAND\": 0,\n",
    "            \"FRANCE\": 0,\n",
    "            \"GERMANY\": 0,\n",
    "            \"ITALY\": 0,\n",
    "            \"RUSSIA\": 0,\n",
    "            \"TURKEY\": 0\n",
    "        },\n",
    "        \"builds\": {\n",
    "            \"AUSTRIA\": {\n",
    "                \"count\": 0,\n",
    "                \"homes\": []\n",
    "            },\n",
    "            \"ENGLAND\": {\n",
    "                \"count\": 0,\n",
    "                \"homes\": []\n",
    "            },\n",
    "            \"FRANCE\": {\n",
    "                \"count\": 0,\n",
    "                \"homes\": []\n",
    "            },\n",
    "            \"GERMANY\": {\n",
    "                \"count\": 0,\n",
    "                \"homes\": []\n",
    "            },\n",
    "            \"ITALY\": {\n",
    "                \"count\": 0,\n",
    "                \"homes\": []\n",
    "            },\n",
    "            \"RUSSIA\": {\n",
    "                \"count\": 0,\n",
    "                \"homes\": []\n",
    "            },\n",
    "            \"TURKEY\": {\n",
    "                \"count\": 0,\n",
    "                \"homes\": []\n",
    "            }\n",
    "        }\n",
    "    },\n",
    "    \"done\": False,\n",
    "    \"agents_data\": {\n",
    "        \"AUT\": {\n",
    "            \"personality\": \"\",\n",
    "            \"goals\": [],\n",
    "            \"journal\": [],\n",
    "            \"model_name\": \"\",\n",
    "            \"relationships\": {\n",
    "                \"AUT-ENG\": \"\",\n",
    "                \"AUT-FRA\": \"\",\n",
    "                \"AUT-GER\": \"\",\n",
    "                \"AUT-ITA\": \"\",\n",
    "                \"AUT-RUS\": \"\",\n",
    "                \"AUT-TUR\": \"\"\n",
    "            }\n",
    "        },\n",
    "        \"ENG\": {\n",
    "            \"personality\": \"\",\n",
    "            \"goals\": [],\n",
    "            \"journal\": [],\n",
    "            \"model_name\": \"\",\n",
    "            \"relationships\": {\n",
    "                \"AUT-ENG\": \"\",\n",
    "                \"ENG-FRA\": \"\",\n",
    "                \"ENG-GER\": \"\",\n",
    "                \"ENG-ITA\": \"\",\n",
    "                \"ENG-RUS\": \"\",\n",
    "                \"ENG-TUR\": \"\"\n",
    "            }\n",
    "        },\n",
    "        \"FRA\": {\n",
    "            \"personality\": \"\",\n",
    "            \"goals\": [],\n",
    "            \"journal\": [],\n",
    "            \"model_name\": \"\",\n",
    "            \"relationships\": {\n",
    "                \"AUT-FRA\": \"\",\n",
    "                \"ENG-FRA\": \"\",\n",
    "                \"FRA-GER\": \"\",\n",
    "                \"FRA-ITA\": \"\",\n",
    "                \"FRA-RUS\": \"\",\n",
    "                \"FRA-TUR\": \"\"\n",
    "            }\n",
    "        },\n",
    "        \"GER\": {\n",
    "            \"personality\": \"\",\n",
    "            \"goals\": [],\n",
    "            \"journal\": [],\n",
    "            \"model_name\": \"\",\n",
    "            \"relationships\": {\n",
    "                \"AUT-GER\": \"\",\n",
    "                \"ENG-GER\": \"\",\n",
    "                \"FRA-GER\": \"\",\n",
    "                \"GER-ITA\": \"\",\n",
    "                \"GER-RUS\": \"\",\n",
    "                \"GER-TUR\": \"\"\n",
    "            }\n",
    "        },\n",
    "        \"ITA\": {\n",
    "            \"personality\": \"\",\n",
    "            \"goals\": [],\n",
    "            \"journal\": [],\n",
    "            \"model_name\": \"\",\n",
    "            \"relationships\": {\n",
    "                \"AUT-ITA\": \"\",\n",
    "                \"ENG-ITA\": \"\",\n",
    "                \"FRA-ITA\": \"\",\n",
    "                \"GER-ITA\": \"\",\n",
    "                \"ITA-RUS\": \"\",\n",
    "                \"ITA-TUR\": \"\"\n",
    "            }\n",
    "        },\n",
    "        \"RUS\": {\n",
    "            \"personality\": \"\",\n",
    "            \"goals\": [],\n",
    "            \"journal\": [],\n",
    "            \"model_name\": \"\",\n",
    "            \"relationships\": {\n",
    "                \"AUT-RUS\": \"\",\n",
    "                \"ENG-RUS\": \"\",\n",
    "                \"FRA-RUS\": \"\",\n",
    "                \"GER-RUS\": \"\",\n",
    "                \"ITA-RUS\": \"\",\n",
    "                \"RUS-TUR\": \"\"\n",
    "            }\n",
    "        },\n",
    "        \"TUR\": {\n",
    "            \"personality\": \"\",\n",
    "            \"goals\": [],\n",
    "            \"journal\": [],\n",
    "            \"model_name\": \"\",\n",
    "            \"relationships\": {\n",
    "                \"AUT-TUR\": \"\",\n",
    "                \"ENG-TUR\": \"\",\n",
    "                \"FRA-TUR\": \"\",\n",
    "                \"GER-TUR\": \"\",\n",
    "                \"ITA-TUR\": \"\",\n",
    "                \"RUS-TUR\": \"\"\n",
    "            }\n",
    "        }\n",
    "    },\n",
    "    \"turn_history\": [\n",
    "        {\n",
    "            \"phase\": \"\",\n",
    "            \"env_state\": {},\n",
    "            \"issued_orders\": {},\n",
    "            \"accepted_orders\": {},\n",
    "            \"player_relationships\": {}\n",
    "        }\n",
    "    ],\n",
    "    \"negotiation_history\": [\n",
    "        {\n",
    "            \"turn_index\": 0,\n",
    "            \"subrounds\": [\n",
    "                {\n",
    "                    \"subround_index\": 0,\n",
    "                    \"sent_missives\": [\n",
    "                        {\"sender\": \"\", \"recipients\": [], \"body\": \"\"}\n",
    "                    ],\n",
    "                    \"received_missives\": {\n",
    "                        \"AUT\": [],\n",
    "                        \"ENG\": [],\n",
    "                        \"FRA\": [],\n",
    "                        \"GER\": [],\n",
    "                        \"ITA\": [],\n",
    "                        \"RUS\": [],\n",
    "                        \"TUR\": []\n",
    "                    }\n",
    "                }\n",
    "            ],\n",
    "            \"final_summaries\": {\n",
    "                \"AUT\": {\n",
    "                    \"journal_summary\": \"\",\n",
    "                    \"intent\": \"\",\n",
    "                    \"rship_updates\": []\n",
    "                },\n",
    "                \"ENG\": {\n",
    "                    \"journal_summary\": \"\",\n",
    "                    \"intent\": \"\",\n",
    "                    \"rship_updates\": []\n",
    "                },\n",
    "                \"FRA\": {\n",
    "                    \"journal_summary\": \"\",\n",
    "                    \"intent\": \"\",\n",
    "                    \"rship_updates\": []\n",
    "                },\n",
    "                \"GER\": {\n",
    "                    \"journal_summary\": \"\",\n",
    "                    \"intent\": \"\",\n",
    "                    \"rship_updates\": []\n",
    "                },\n",
    "                \"ITA\": {\n",
    "                    \"journal_summary\": \"\",\n",
    "                    \"intent\": \"\",\n",
    "                    \"rship_updates\": []\n",
    "                },\n",
    "                \"RUS\": {\n",
    "                    \"journal_summary\": \"\",\n",
    "                    \"intent\": \"\",\n",
    "                    \"rship_updates\": []\n",
    "                },\n",
    "                \"TUR\": {\n",
    "                    \"journal_summary\": \"\",\n",
    "                    \"intent\": \"\",\n",
    "                    \"rship_updates\": []\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def parse_phase(phase_str: str) -> Tuple[int,int,str]:\n",
    "    \"\"\"\n",
    "    Attempt to parse a phase like \"S1901M\" or \"F1901A\" or \"W1902R\"\n",
    "    Return (year, season_order, pretty_label)\n",
    "      season_order: 1=Spring, 2=Fall, 3=Winter (arbitrary choice)\n",
    "      pretty_label: \"1901 Spring\", \"1901 Fall\", \"1901 Winter\"\n",
    "    If parsing fails, fallback to (9999, 9, phase_str).\n",
    "    \"\"\"\n",
    "    if len(phase_str) < 5:\n",
    "        return (9999, 9, phase_str)\n",
    "\n",
    "    season_char = phase_str[0]\n",
    "    year_str = phase_str[1:5]\n",
    "    try:\n",
    "        year = int(year_str)\n",
    "    except ValueError:\n",
    "        return (9999, 9, phase_str)\n",
    "\n",
    "    if season_char == 'S':\n",
    "        season_txt = \"Spring\"\n",
    "        season_order = 1\n",
    "    elif season_char == 'F':\n",
    "        season_txt = \"Fall\"\n",
    "        season_order = 2\n",
    "    elif season_char == 'W':\n",
    "        season_txt = \"Winter\"\n",
    "        season_order = 3\n",
    "    else:\n",
    "        season_txt = \"Unknown\"\n",
    "        season_order = 9\n",
    "\n",
    "    pretty_label = f\"{year} {season_txt}\"\n",
    "    return (year, season_order, pretty_label)\n",
    "\n",
    "def relationship_to_numeric(relationship_str: str) -> int:\n",
    "    \"\"\"\n",
    "    Convert the relationship string into numeric form:\n",
    "      \"++\" =>  2\n",
    "      \"+\"  =>  1\n",
    "      \"~\"  =>  0\n",
    "      \"-\"  => -1\n",
    "      \"--\" => -2\n",
    "    \"\"\"\n",
    "    mapping = {\"++\": 2, \"+\": 1, \"~\": 0, \"-\": -1, \"--\": -2}\n",
    "    return mapping.get(relationship_str, 0)\n",
    "\n",
    "###############################################################################\n",
    "# 1) Parse stats for AUT, sorted by chronological phase\n",
    "###############################################################################\n",
    "def parse_aut_statistics(game_data: Dict[str, Any]) -> Dict[str, Any]:\n",
    "    \"\"\"\n",
    "    Return an OrderedDict-like structure (phase_label -> stats).\n",
    "    We'll sort phases by chronological order. Stats:\n",
    "      {\n",
    "        \"centers_count\": int,\n",
    "        \"units_count\": int,\n",
    "        \"influence_count\": int,\n",
    "        \"builds_count\": int,\n",
    "        \"civil_disorder\": int,\n",
    "        \"relationships_self\": { \"AUT-ENG\": int, ... },\n",
    "        \"relationships_others\": { \"ENG-AUT\": int, ... },\n",
    "        \"phase_str\": the raw string from JSON,\n",
    "        \"phase_label\": \"1901 Spring\" etc\n",
    "      }\n",
    "    \"\"\"\n",
    "    turn_history = game_data.get(\"turn_history\", [])\n",
    "    info_list = []\n",
    "    for turn in turn_history:\n",
    "        phase_str = turn.get(\"phase\", \"UnknownPhase\")\n",
    "        (year, season_ord, nice_label) = parse_phase(phase_str)\n",
    "\n",
    "        env_state = turn.get(\"env_state\", {})\n",
    "        centers_aut = env_state.get(\"centers\", {}).get(\"AUSTRIA\", [])\n",
    "        units_aut = env_state.get(\"units\", {}).get(\"AUSTRIA\", [])\n",
    "        influence_aut = env_state.get(\"influence\", {}).get(\"AUSTRIA\", [])\n",
    "        builds_data = env_state.get(\"builds\", {}).get(\"AUSTRIA\", {})\n",
    "        build_count = builds_data.get(\"count\", 0)\n",
    "        civ_dis = env_state.get(\"civil_disorder\", {}).get(\"AUSTRIA\", 0)\n",
    "\n",
    "        # relationships\n",
    "        relationships_self = {}\n",
    "        relationships_others = {}\n",
    "\n",
    "        pr = turn.get(\"player_relationships\", {})\n",
    "        aut_rel = pr.get(\"AUT\", {})\n",
    "        for rk, rv in aut_rel.items():\n",
    "            relationships_self[rk] = relationship_to_numeric(rv)\n",
    "\n",
    "        for power, rel_map in pr.items():\n",
    "            if power == \"AUT\":\n",
    "                continue\n",
    "            for rk, rv in rel_map.items():\n",
    "                if \"AUT\" in rk:\n",
    "                    relationships_others[rk] = relationship_to_numeric(rv)\n",
    "\n",
    "        info_list.append({\n",
    "            \"phase\": phase_str,\n",
    "            \"phase_label\": nice_label,\n",
    "            \"sort_key\": (year, season_ord),\n",
    "            \"centers_count\": len(centers_aut),\n",
    "            \"units_count\": len(units_aut),\n",
    "            \"influence_count\": len(influence_aut),\n",
    "            \"builds_count\": build_count,\n",
    "            \"civil_disorder\": civ_dis,\n",
    "            \"relationships_self\": relationships_self,\n",
    "            \"relationships_others\": relationships_others\n",
    "        })\n",
    "\n",
    "    info_list.sort(key=lambda x: x[\"sort_key\"])\n",
    "\n",
    "    final_dict = {}\n",
    "    label_count = {}\n",
    "    for entry in info_list:\n",
    "        plabel = entry[\"phase_label\"]\n",
    "        if plabel in final_dict:\n",
    "            label_count[plabel] = label_count.get(plabel, 1) + 1\n",
    "            suffix = f\"({label_count[plabel]})\"\n",
    "            plabel = f\"{plabel}{suffix}\"\n",
    "        else:\n",
    "            label_count[plabel] = 1\n",
    "        final_dict[plabel] = entry\n",
    "\n",
    "    return final_dict\n",
    "\n",
    "###############################################################################\n",
    "# 2) Parse negotiations for AUT, also sorted by turn_index, \n",
    "#    and label them with the matching phase label if possible\n",
    "###############################################################################\n",
    "def parse_aut_negotiations(game_data: Dict[str, Any], stats_dict: Dict[str, Any]) -> List[Dict[str, Any]]:\n",
    "    \"\"\"\n",
    "    negotiation_history: each item is { \"turn_index\": int, ... } \n",
    "    We'll find the corresponding turn_history[turn_index] for the phase => label\n",
    "    Then produce a structure like:\n",
    "      [\n",
    "        {\n",
    "          \"turn_index\": X,\n",
    "          \"phase_label\": \"1901 Spring\",\n",
    "          \"subrounds\": [...],\n",
    "          \"final_summary\": { ... }\n",
    "        }, ...\n",
    "      ]\n",
    "    Sorted by turn_index ascending.\n",
    "    \"\"\"\n",
    "    neg_data = []\n",
    "    negotiation_history = game_data.get(\"negotiation_history\", [])\n",
    "    negotiation_history.sort(key=lambda x: x.get(\"turn_index\", -1))\n",
    "    \n",
    "    year_counts = {}\n",
    "    \n",
    "    for turn_neg in negotiation_history:\n",
    "        tindex = turn_neg.get(\"turn_index\", -1)\n",
    "        \n",
    "        if \"phase\" in turn_neg:\n",
    "            phase_str = turn_neg[\"phase\"]\n",
    "            _, _, nice_label = parse_phase(phase_str)\n",
    "        else:\n",
    "            year = 1901 + (tindex // 2)\n",
    "            if year not in year_counts:\n",
    "                year_counts[year] = 0\n",
    "                season = \"Spring\"\n",
    "            else:\n",
    "                year_counts[year] += 1\n",
    "                if year_counts[year] % 2 == 0:\n",
    "                    season = \"Spring\"\n",
    "                else:\n",
    "                    season = \"Fall\"\n",
    "            phase_str = f\"{'S' if season == 'Spring' else 'F'}{year}M\"\n",
    "            nice_label = f\"{year} {season}\"\n",
    "        \n",
    "        subrounds = turn_neg.get(\"subrounds\", [])\n",
    "        final_summaries = turn_neg.get(\"final_summaries\", {})\n",
    "        aut_summary = final_summaries.get(\"AUT\", {})\n",
    "\n",
    "        sr_list = []\n",
    "        for sr in subrounds:\n",
    "            sr_idx = sr.get(\"subround_index\", -1)\n",
    "            sent_all = sr.get(\"sent_missives\", [])\n",
    "            sent_aut = [m for m in sent_all if m.get(\"sender\") == \"AUT\"]\n",
    "            recv_aut = sr.get(\"received_missives\", {}).get(\"AUT\", [])\n",
    "            sr_list.append({\n",
    "                \"subround_index\": sr_idx,\n",
    "                \"sent_by_aut\": sent_aut,\n",
    "                \"received_by_aut\": recv_aut\n",
    "            })\n",
    "\n",
    "        neg_data.append({\n",
    "            \"turn_index\": tindex,\n",
    "            \"phase\": phase_str,\n",
    "            \"phase_label\": nice_label,\n",
    "            \"subrounds\": sr_list,\n",
    "            \"final_summary\": {\n",
    "                \"journal_summary\": aut_summary.get(\"journal_summary\", \"\"),\n",
    "                \"intent\": aut_summary.get(\"intent\", \"\"),\n",
    "                \"rship_updates\": aut_summary.get(\"rship_updates\", [])\n",
    "            }\n",
    "        })\n",
    "\n",
    "    return neg_data\n",
    "\n",
    "###############################################################################\n",
    "# 3) HTML generation with Bootstrap + Chart.js\n",
    "###############################################################################\n",
    "def generate_html_report(\n",
    "    game_data: Dict[str, Any],\n",
    "    stats_for_aut: Dict[str, Any], \n",
    "    negotiations_data: List[Dict[str, Any]]\n",
    ") -> str:\n",
    "    \"\"\"\n",
    "    - stats_for_aut is an ordered dict-like: { \"1901 Spring\": { centers_count, ...}, \"1901 Fall\": {...}, ... }\n",
    "    - negotiations_data is a list sorted by turn_index, each with a known phase_label.\n",
    "    \"\"\"\n",
    "    import math\n",
    "    import os\n",
    "    import glob\n",
    "    \n",
    "    # --------------------------------------------------------\n",
    "    # HELPER to turn \"F1907M\" into \"1907 Fall Movement\", etc.\n",
    "    # --------------------------------------------------------\n",
    "    def make_friendly_label(raw_phase: str) -> str:\n",
    "        # raw_phase could be \"S1901M\", \"F1907A\", \"W1905R\", etc.\n",
    "        # parse_phase() gives us (year, season_order, \"1907 Fall\")\n",
    "        # then we can read the trailing character for M=Movement, A=Adjustment, R=Retreat, etc.\n",
    "        (yr, _, season_str) = parse_phase(raw_phase)\n",
    "        suffix = raw_phase[5:].strip()  # e.g. \"M\", \"A\", \"R\"...\n",
    "\n",
    "        # If there's more than one trailing char (e.g. \"MA\"? Rare), handle gracefully\n",
    "        # Typically you see a single letter but let's handle multiple:\n",
    "        # For example, \"M\" => Movement, \"A\" => Adjustment, \"R\" => Retreat\n",
    "        # If multiple, just join them; or you can expand as needed.\n",
    "        suffix_map = {\n",
    "            'M': 'Movement',\n",
    "            'A': 'Adjustment',\n",
    "            'R': 'Retreat',\n",
    "            # etc. If you have others like 'B' or 'D' you can add them here\n",
    "        }\n",
    "        # Convert each character in suffix into a descriptive label if known, otherwise keep it\n",
    "        suffix_str_parts = []\n",
    "        for ch in suffix:\n",
    "            suffix_str_parts.append(suffix_map.get(ch, ch))\n",
    "        suffix_str = \" \".join(suffix_str_parts).strip()\n",
    "\n",
    "        # result example: \"1907 Fall Movement\"\n",
    "        # if suffix_str is empty, we’ll just show e.g. \"1907 Fall\"\n",
    "        final_label = season_str\n",
    "        if suffix_str:\n",
    "            final_label = f\"{season_str} {suffix_str}\"\n",
    "\n",
    "        return f\"{yr} {final_label}\".strip()\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # (1) Possibly gather raw phases in a list that lines up with stats_for_aut’s order\n",
    "    #     So our x-axis is something like [\"F1907M\",\"W1907R\",...] but displayed readably.\n",
    "    # --------------------------------------------------------\n",
    "    \n",
    "    # Pull the sorted \"display keys\" from stats_for_aut\n",
    "    display_keys = list(stats_for_aut.keys())  # e.g. [\"1901 Spring\", \"1901 Fall\", ...] but in sorted order\n",
    "    # We will extract the actual raw_phase from each stats entry:\n",
    "    raw_phases = []\n",
    "    friendly_phases = []\n",
    "\n",
    "    for disp_key in display_keys:\n",
    "        raw_p = stats_for_aut[disp_key][\"phase\"]  # e.g. \"F1907M\"\n",
    "        raw_phases.append(raw_p)\n",
    "        friendly_phases.append(make_friendly_label(raw_p))\n",
    "    \n",
    "    # --------------------------------------------------------\n",
    "    # (2) Gather all the metric arrays in that same order\n",
    "    # --------------------------------------------------------\n",
    "    centers_arr = []\n",
    "    units_arr = []\n",
    "    influence_arr = []\n",
    "    builds_arr = []\n",
    "    civdis_arr = []\n",
    "\n",
    "    for disp_key in display_keys:\n",
    "        d = stats_for_aut[disp_key]\n",
    "        centers_arr.append(d[\"centers_count\"])\n",
    "        units_arr.append(d[\"units_count\"])\n",
    "        influence_arr.append(d[\"influence_count\"])\n",
    "        builds_arr.append(d[\"builds_count\"])\n",
    "        civdis_arr.append(d[\"civil_disorder\"])\n",
    "    \n",
    "    # For relationships\n",
    "    all_self_keys = set()\n",
    "    all_others_keys = set()\n",
    "    for disp_key in display_keys:\n",
    "        d = stats_for_aut[disp_key]\n",
    "        all_self_keys.update(d[\"relationships_self\"].keys())\n",
    "        all_others_keys.update(d[\"relationships_others\"].keys())\n",
    "\n",
    "    all_self_keys = sorted(list(all_self_keys))\n",
    "    all_others_keys = sorted(list(all_others_keys))\n",
    "\n",
    "    self_rels_data = {k: [] for k in all_self_keys}\n",
    "    others_rels_data = {k: [] for k in all_others_keys}\n",
    "\n",
    "    self_agg_arr = []\n",
    "    others_agg_arr = []\n",
    "\n",
    "    for disp_key in display_keys:\n",
    "        d = stats_for_aut[disp_key]\n",
    "        # self\n",
    "        rs_self = d[\"relationships_self\"]\n",
    "        if rs_self:\n",
    "            sum_val = 0\n",
    "            for k in all_self_keys:\n",
    "                v = rs_self.get(k, 0)\n",
    "                self_rels_data[k].append(v)\n",
    "                sum_val += v\n",
    "            avg_self = sum_val / len(all_self_keys)\n",
    "        else:\n",
    "            for k in all_self_keys:\n",
    "                self_rels_data[k].append(0)\n",
    "            avg_self = 0\n",
    "        self_agg_arr.append(avg_self)\n",
    "\n",
    "        # others\n",
    "        rs_others = d[\"relationships_others\"]\n",
    "        if rs_others:\n",
    "            sum_val = 0\n",
    "            for k in all_others_keys:\n",
    "                v = rs_others.get(k, 0)\n",
    "                others_rels_data[k].append(v)\n",
    "                sum_val += v\n",
    "            avg_oth = sum_val / len(all_others_keys)\n",
    "        else:\n",
    "            for k in all_others_keys:\n",
    "                others_rels_data[k].append(0)\n",
    "            avg_oth = 0\n",
    "        others_agg_arr.append(avg_oth)\n",
    "\n",
    "    # top-level sums\n",
    "    def avg_of(arr):\n",
    "        return sum(arr) / len(arr) if arr else 0\n",
    "    def last_of(arr):\n",
    "        return arr[-1] if arr else 0\n",
    "\n",
    "    avg_centers = avg_of(centers_arr)\n",
    "    final_centers = last_of(centers_arr)\n",
    "    avg_units = avg_of(units_arr)\n",
    "    final_units = last_of(units_arr)\n",
    "    avg_influence = avg_of(influence_arr)\n",
    "    final_influence = last_of(influence_arr)\n",
    "    avg_selfr = avg_of(self_agg_arr)\n",
    "    final_selfr = last_of(self_agg_arr)\n",
    "    avg_othr = avg_of(others_agg_arr)\n",
    "    final_othr = last_of(others_agg_arr)\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # (3) Collect Orders (Issued / Valid / Rejected) for each raw phase\n",
    "    # --------------------------------------------------------\n",
    "    orders_issued_arr = []\n",
    "    orders_valid_arr = []\n",
    "    orders_rejected_arr = []\n",
    "    turn_history = game_data.get(\"turn_history\", [])\n",
    "\n",
    "    for rp in raw_phases:\n",
    "        # find the corresponding turn\n",
    "        matching_turn = None\n",
    "        for th in turn_history:\n",
    "            if th.get(\"phase\") == rp:\n",
    "                matching_turn = th\n",
    "                break\n",
    "        if matching_turn:\n",
    "            all_issued = matching_turn.get(\"issued_orders\", {}).get(\"AUT\", [])\n",
    "            all_accepted = matching_turn.get(\"accepted_orders\", {}).get(\"AUT\", [])\n",
    "            n_issued = len(all_issued)\n",
    "            n_valid = len(all_accepted)\n",
    "            n_rejected = n_issued - n_valid\n",
    "        else:\n",
    "            n_issued = 0\n",
    "            n_valid = 0\n",
    "            n_rejected = 0\n",
    "\n",
    "        orders_issued_arr.append(n_issued)\n",
    "        orders_valid_arr.append(n_valid)\n",
    "        orders_rejected_arr.append(n_rejected)\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # (4) Start building HTML\n",
    "    # --------------------------------------------------------\n",
    "    import html as html_lib  # if needed for escaping\n",
    "    import urllib\n",
    "    import sys\n",
    "\n",
    "    html = []\n",
    "    html.append(\"<!DOCTYPE html><html lang='en'><head>\")\n",
    "    html.append(\"<meta charset='utf-8'/>\")\n",
    "    html.append(\"<meta name='viewport' content='width=device-width, initial-scale=1'/>\")\n",
    "    html.append(\"<title>Diplomacy - AUT Report</title>\")\n",
    "\n",
    "    # Bootstrap + Chart.js\n",
    "    html.append(\"<link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'/>\")\n",
    "    html.append(\"<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>\")\n",
    "    html.append(\"<style>\")\n",
    "    html.append(\"\"\"\n",
    "    .svg-player-container {\n",
    "        position: relative;\n",
    "        width: 100%;\n",
    "        max-width: 1000px;\n",
    "        margin: 0 auto;\n",
    "        background-color: #f8f9fa;\n",
    "        border-radius: 8px;\n",
    "        overflow: hidden;\n",
    "    }\n",
    "    .svg-display {\n",
    "        width: 100%;\n",
    "        height: 600px;\n",
    "        background-color: white;\n",
    "        display: flex;\n",
    "        align-items: center;\n",
    "        justify-content: center;\n",
    "        overflow: hidden;\n",
    "    }\n",
    "    .svg-display object, .svg-display img {\n",
    "        max-width: 100%;\n",
    "        max-height: 100%;\n",
    "        object-fit: contain;\n",
    "    }\n",
    "    .player-controls {\n",
    "        padding: 15px;\n",
    "        background-color: #e9ecef;\n",
    "        display: flex;\n",
    "        align-items: center;\n",
    "        gap: 10px;\n",
    "    }\n",
    "    .progress-container {\n",
    "        flex-grow: 1;\n",
    "        height: 10px;\n",
    "        background-color: #ced4da;\n",
    "        border-radius: 5px;\n",
    "        position: relative;\n",
    "        cursor: pointer;\n",
    "    }\n",
    "    .progress-bar {\n",
    "        height: 100%;\n",
    "        background-color: #0d6efd;\n",
    "        border-radius: 5px;\n",
    "        width: 0%;\n",
    "    }\n",
    "    .phase-label {\n",
    "        font-weight: bold;\n",
    "        min-width: 120px;\n",
    "        text-align: center;\n",
    "    }\n",
    "    .control-button {\n",
    "        background-color: #6c757d;\n",
    "        color: white;\n",
    "        border: none;\n",
    "        border-radius: 4px;\n",
    "        padding: 5px 10px;\n",
    "        cursor: pointer;\n",
    "    }\n",
    "    .control-button:hover {\n",
    "        background-color: #5a6268;\n",
    "    }\n",
    "    .control-button:disabled {\n",
    "        background-color: #adb5bd;\n",
    "        cursor: not-allowed;\n",
    "    }\n",
    "    \"\"\")\n",
    "    html.append(\"</style>\")\n",
    "    html.append(\"</head><body class='bg-light'>\")\n",
    "    html.append(\"<div class='container mt-4'>\")\n",
    "    html.append(\"<h1>Diplomacy Report for Austria (AUT)</h1>\")\n",
    "\n",
    "    # Basic info\n",
    "    game_id = game_data.get(\"game_id\",\"Unknown\")\n",
    "    done_flag = game_data.get(\"done\", False)\n",
    "    html.append(f\"<h4><strong>Game ID:</strong> {game_id}</h4>\")    \n",
    "\n",
    "    # Overall Stats\n",
    "    html.append(\"\"\"\n",
    "    <div class=\"card mb-3\">\n",
    "      <div class=\"card-body\">\n",
    "        <h4>Overall Stats</h4>\n",
    "    \"\"\")\n",
    "    html.append(\"<ul>\")\n",
    "    html.append(f\"<li><b>Avg Centers:</b> {avg_centers:.2f}, <b>Final:</b> {final_centers}</li>\")\n",
    "    html.append(f\"<li><b>Avg Units:</b> {avg_units:.2f}, <b>Final:</b> {final_units}</li>\")\n",
    "    html.append(f\"<li><b>Avg Influence:</b> {avg_influence:.2f}, <b>Final:</b> {final_influence}</li>\")\n",
    "    html.append(f\"<li><b>Avg Self-Relationship:</b> {avg_selfr:.2f}, <b>Final:</b> {final_selfr:.2f}</li>\")\n",
    "    html.append(f\"<li><b>Avg Others-Relationship:</b> {avg_othr:.2f}, <b>Final:</b> {final_othr:.2f}</li>\")\n",
    "    html.append(\"</ul>\")\n",
    "    html.append(\"\"\"\n",
    "      </div>\n",
    "    </div>\n",
    "    \"\"\")\n",
    "\n",
    "    # Tabs\n",
    "    svg_files = []\n",
    "    run_id = game_id\n",
    "    svg_dir = f\"gamestate_renders/{run_id}\"\n",
    "    if os.path.exists(svg_dir):\n",
    "        import glob\n",
    "        svg_pattern = os.path.join(svg_dir, \"gamestate_*.svg\")\n",
    "        svg_files = glob.glob(svg_pattern)\n",
    "\n",
    "    html.append(\"\"\"\n",
    "<ul class=\"nav nav-tabs\" id=\"myTab\" role=\"tablist\">\n",
    "  <li class=\"nav-item\" role=\"presentation\">\n",
    "    <button class=\"nav-link active\" id=\"stats-tab\" data-bs-toggle=\"tab\" data-bs-target=\"#statsTabContent\" type=\"button\" role=\"tab\" aria-controls=\"statsTabContent\" aria-selected=\"true\">AUT Charts</button>\n",
    "  </li>\n",
    "  <li class=\"nav-item\" role=\"presentation\">\n",
    "    <button class=\"nav-link\" id=\"negotiation-tab\" data-bs-toggle=\"tab\" data-bs-target=\"#negotiationTabContent\" type=\"button\" role=\"tab\" aria-controls=\"negotiationTabContent\" aria-selected=\"false\">Negotiations</button>\n",
    "  </li>\n",
    "\"\"\")\n",
    "    if svg_files:\n",
    "        html.append(\"\"\"  \n",
    "  <li class=\"nav-item\" role=\"presentation\">\n",
    "    <button class=\"nav-link\" id=\"animation-tab\" data-bs-toggle=\"tab\" data-bs-target=\"#animationTabContent\" type=\"button\" role=\"tab\" aria-controls=\"animationTabContent\" aria-selected=\"false\">Game Animation</button>\n",
    "  </li>\n",
    "\"\"\")\n",
    "    html.append(\"\"\"\n",
    "</ul>\n",
    "<div class=\"tab-content\" id=\"myTabContent\">\n",
    "  <!-- STATS TAB -->\n",
    "  <div class=\"tab-pane fade show active p-3\" id=\"statsTabContent\" role=\"tabpanel\" aria-labelledby=\"stats-tab\">\n",
    "\"\"\")\n",
    "\n",
    "    # Main Metrics\n",
    "    html.append(\"<h3>Main Metrics</h3>\")\n",
    "    html.append(\"<canvas id='mainMetricsChart' width='800' height='300'></canvas>\")\n",
    "\n",
    "    # Self Rels\n",
    "    html.append(\"<hr/><h3>Relationships (Self-Perceived)</h3>\")\n",
    "    html.append(\"<canvas id='selfRelsChart' width='800' height='300'></canvas>\")\n",
    "\n",
    "    # Others Rels\n",
    "    html.append(\"<hr/><h3>Relationships (Others → AUT)</h3>\")\n",
    "    html.append(\"<canvas id='othersRelsChart' width='800' height='300'></canvas>\")\n",
    "\n",
    "    # Orders Chart\n",
    "    html.append(\"<hr/><h3>Orders: Issued vs Valid vs Rejected</h3>\")\n",
    "    html.append(\"<canvas id='ordersChart' width='800' height='300'></canvas>\")\n",
    "\n",
    "    html.append(\"</div>\")  # end statsTabContent\n",
    "\n",
    "    # Negotiation Tab\n",
    "    html.append(\"\"\"\n",
    "  <div class=\"tab-pane fade p-3\" id=\"negotiationTabContent\" role=\"tabpanel\" aria-labelledby=\"negotiation-tab\">\n",
    "    <h2>Negotiations / Dialogues</h2>\n",
    "\"\"\")\n",
    "    # Show negotiations\n",
    "    html.append('<div class=\"accordion\" id=\"negAccordion\">')\n",
    "    for i, nd in enumerate(negotiations_data):\n",
    "        tindex = nd[\"turn_index\"]\n",
    "        ph_label = nd[\"phase_label\"] if nd[\"phase_label\"] else nd[\"phase\"]\n",
    "        subrounds = nd[\"subrounds\"]\n",
    "        final_sum = nd[\"final_summary\"]\n",
    "\n",
    "        heading_id = f\"negHeading{i}\"\n",
    "        collapse_id = f\"negCollapse{i}\"\n",
    "\n",
    "        title_str = f\"Negotiation Turn {tindex} ({ph_label})\"\n",
    "        html.append(f\"\"\"\n",
    "  <div class=\"accordion-item\">\n",
    "    <h2 class=\"accordion-header\" id=\"{heading_id}\">\n",
    "      <button class=\"accordion-button collapsed\" type=\"button\" data-bs-toggle=\"collapse\" data-bs-target=\"#{collapse_id}\" aria-expanded=\"false\" aria-controls=\"{collapse_id}\">\n",
    "        {title_str}\n",
    "      </button>\n",
    "    </h2>\n",
    "    <div id=\"{collapse_id}\" class=\"accordion-collapse collapse\" aria-labelledby=\"{heading_id}\" data-bs-parent=\"#negAccordion\">\n",
    "      <div class=\"accordion-body\">\n",
    "\"\"\")\n",
    "        # Subrounds\n",
    "        for sr_obj in subrounds:\n",
    "            sr_idx = sr_obj[\"subround_index\"]\n",
    "            sents = sr_obj[\"sent_by_aut\"]\n",
    "            recvs = sr_obj[\"received_by_aut\"]\n",
    "\n",
    "            html.append(f\"<div class='mb-2'><b>Subround {sr_idx}</b></div>\")\n",
    "            if sents:\n",
    "                html.append(\"<div class='ms-4'><u>Sent by AUT:</u><ul>\")\n",
    "                for msg in sents:\n",
    "                    to_ = \", \".join(msg.get(\"recipients\", []))\n",
    "                    body_ = msg.get(\"body\",\"\")\n",
    "                    html.append(f\"<li><b>To</b> [{to_}]: {body_}</li>\")\n",
    "                html.append(\"</ul></div>\")\n",
    "\n",
    "            if recvs:\n",
    "                html.append(\"<div class='ms-4'><u>Received by AUT:</u><ul>\")\n",
    "                for msg in recvs:\n",
    "                    sender_ = msg.get(\"sender\",\"\")\n",
    "                    body_ = msg.get(\"body\",\"\")\n",
    "                    html.append(f\"<li><b>From</b> [{sender_}]: {body_}</li>\")\n",
    "                html.append(\"</ul></div>\")\n",
    "\n",
    "        html.append(\"<hr/>\")\n",
    "        html.append(\"<p><b>Final Summary (AUT):</b></p>\")\n",
    "        html.append(\"<ul>\")\n",
    "        jsum = final_sum[\"journal_summary\"]\n",
    "        jintent = final_sum[\"intent\"]\n",
    "        jrship = final_sum[\"rship_updates\"]\n",
    "        html.append(f\"<li><i>Journal Summary:</i> {jsum}</li>\")\n",
    "        html.append(f\"<li><i>Intent:</i> {jintent}</li>\")\n",
    "        if jrship:\n",
    "            html.append(f\"<li><i>Relationship Updates:</i> {jrship}</li>\")\n",
    "        html.append(\"</ul>\")\n",
    "\n",
    "        html.append(\"\"\"\n",
    "      </div>\n",
    "    </div>\n",
    "  </div>\n",
    "\"\"\")\n",
    "    html.append(\"</div>\")  # end accordion\n",
    "    html.append(\"</div>\")  # end negotiationTabContent\n",
    "\n",
    "    # Animation tab\n",
    "    if svg_files:\n",
    "        # Sort them to match chronological order\n",
    "        def extract_phase_from_filename(filename):\n",
    "            import os\n",
    "            base = os.path.basename(filename)\n",
    "            ph = base.replace(\"gamestate_\",\"\").replace(\".svg\",\"\")\n",
    "            (y, s, _) = parse_phase(ph)\n",
    "            return (y, s)\n",
    "        svg_files.sort(key=extract_phase_from_filename)\n",
    "\n",
    "        # Build JS arrays\n",
    "        import os\n",
    "        svg_paths_js = \"[\" + \",\".join(f\"'{path}'\" for path in svg_files) + \"]\"\n",
    "        # Also build friendly labels for each:\n",
    "        svg_phases = []\n",
    "        for f in svg_files:\n",
    "            base = os.path.basename(f)\n",
    "            rp = base.replace(\"gamestate_\",\"\").replace(\".svg\",\"\")\n",
    "            svg_phases.append(make_friendly_label(rp))\n",
    "        svg_phases_js = \"[\" + \",\".join(f\"'{x}'\" for x in svg_phases) + \"]\"\n",
    "\n",
    "        html.append(\"\"\"\n",
    "  <div class=\"tab-pane fade p-3\" id=\"animationTabContent\" role=\"tabpanel\" aria-labelledby=\"animation-tab\">\n",
    "    <h2>Game Animation</h2>\n",
    "    <div class=\"svg-player-container\">\n",
    "      <div class=\"svg-display\" id=\"svgDisplay\">\n",
    "      </div>\n",
    "      <div class=\"player-controls\">\n",
    "        <button class=\"control-button\" id=\"prevBtn\">◀</button>\n",
    "        <button class=\"control-button\" id=\"playPauseBtn\">▶</button>\n",
    "        <button class=\"control-button\" id=\"nextBtn\">▶</button>\n",
    "        <div class=\"progress-container\" id=\"progressContainer\">\n",
    "          <div class=\"progress-bar\" id=\"progressBar\"></div>\n",
    "        </div>\n",
    "        <div class=\"phase-label\" id=\"phaseLabel\"></div>\n",
    "      </div>\n",
    "    </div>\n",
    "  </div>\n",
    "\"\"\")\n",
    "\n",
    "    html.append(\"</div>\")  # end .tab-content\n",
    "    html.append(\"</div>\")  # end .container\n",
    "\n",
    "    # --------------------------------------------------------\n",
    "    # Chart.js generation\n",
    "    # --------------------------------------------------------\n",
    "    html.append(\"<script>\")\n",
    "\n",
    "    # JavaScript array of friendly labels for the x-axis\n",
    "    def arr_js_str(string_list: List[str]) -> str:\n",
    "        return \"[\" + \",\".join(f\"'{s}'\" for s in string_list) + \"]\"\n",
    "\n",
    "    # Main metrics\n",
    "    main_labels_js = arr_js_str(friendly_phases)\n",
    "    centers_js = \"[\" + \",\".join(str(x) for x in centers_arr) + \"]\"\n",
    "    units_js = \"[\" + \",\".join(str(x) for x in units_arr) + \"]\"\n",
    "    infl_js = \"[\" + \",\".join(str(x) for x in influence_arr) + \"]\"\n",
    "    builds_js = \"[\" + \",\".join(str(x) for x in builds_arr) + \"]\"\n",
    "    civdis_js = \"[\" + \",\".join(str(x) for x in civdis_arr) + \"]\"\n",
    "\n",
    "    html.append(f\"\"\"\n",
    "    var ctxMain = document.getElementById('mainMetricsChart').getContext('2d');\n",
    "    var mainMetricsChart = new Chart(ctxMain, {{\n",
    "      type: 'line',\n",
    "      data: {{\n",
    "        labels: {main_labels_js},\n",
    "        datasets: [\n",
    "          {{\n",
    "            label: 'Centers',\n",
    "            data: {centers_js},\n",
    "            borderColor: 'red',\n",
    "            fill: false\n",
    "          }},\n",
    "          {{\n",
    "            label: 'Units',\n",
    "            data: {units_js},\n",
    "            borderColor: 'blue',\n",
    "            fill: false\n",
    "          }},\n",
    "          {{\n",
    "            label: 'Influence',\n",
    "            data: {infl_js},\n",
    "            borderColor: 'green',\n",
    "            fill: false\n",
    "          }},\n",
    "          {{\n",
    "            label: 'Builds',\n",
    "            data: {builds_js},\n",
    "            borderColor: 'purple',\n",
    "            fill: false\n",
    "          }},\n",
    "          {{\n",
    "            label: 'Civil Disorder',\n",
    "            data: {civdis_js},\n",
    "            borderColor: 'orange',\n",
    "            fill: false\n",
    "          }}\n",
    "        ]\n",
    "      }},\n",
    "      options: {{\n",
    "        responsive: true,\n",
    "        scales: {{\n",
    "          y: {{\n",
    "            beginAtZero: true\n",
    "          }}\n",
    "        }}\n",
    "      }}\n",
    "    }});\n",
    "\"\"\")\n",
    "\n",
    "    # Relationship charts\n",
    "    color_palette = [\n",
    "        \"maroon\",\"steelblue\",\"darkgreen\",\"purple\",\"darkorange\",\n",
    "        \"navy\",\"fuchsia\",\"darkcyan\",\"brown\",\"teal\",\"black\"\n",
    "    ]\n",
    "    def build_rel_datasets(\n",
    "        data_map: Dict[str, List[int]], \n",
    "        keys: List[str], \n",
    "        extra_line: List[float], \n",
    "        extra_label: str\n",
    "    ) -> str:\n",
    "        lines = []\n",
    "        idx = 0\n",
    "        for k in keys:\n",
    "            color = color_palette[idx % len(color_palette)]\n",
    "            vals = data_map[k]\n",
    "            vals_js = \"[\" + \",\".join(str(v) for v in vals) + \"]\"\n",
    "            lines.append(f\"\"\"\n",
    "            {{\n",
    "              label: '{k}',\n",
    "              data: {vals_js},\n",
    "              borderColor: '{color}',\n",
    "              fill: false\n",
    "            }}\n",
    "            \"\"\")\n",
    "            idx += 1\n",
    "        # aggregator line\n",
    "        agg_js = \"[\" + \",\".join(f\"{v}\" for v in extra_line) + \"]\"\n",
    "        lines.append(f\"\"\"\n",
    "        {{\n",
    "          label: '{extra_label}',\n",
    "          data: {agg_js},\n",
    "          borderColor: 'black',\n",
    "          borderDash: [5,5],\n",
    "          fill: false\n",
    "        }}\n",
    "        \"\"\")\n",
    "        return \",\".join(lines)\n",
    "\n",
    "    # Self relationships\n",
    "    self_rel_ds = build_rel_datasets(self_rels_data, all_self_keys, self_agg_arr, \"Aggregate Self\")\n",
    "    html.append(f\"\"\"\n",
    "    var ctxSelf = document.getElementById('selfRelsChart').getContext('2d');\n",
    "    var selfRelsChart = new Chart(ctxSelf, {{\n",
    "      type: 'line',\n",
    "      data: {{\n",
    "        labels: {main_labels_js},\n",
    "        datasets: [{self_rel_ds}]\n",
    "      }},\n",
    "      options: {{\n",
    "        responsive: true,\n",
    "        scales: {{\n",
    "          y: {{\n",
    "            min: -2,\n",
    "            max: 2,\n",
    "            ticks: {{\n",
    "              stepSize: 1\n",
    "            }}\n",
    "          }}\n",
    "        }}\n",
    "      }}\n",
    "    }});\n",
    "\"\"\")\n",
    "\n",
    "    # Others relationships\n",
    "    others_rel_ds = build_rel_datasets(others_rels_data, all_others_keys, others_agg_arr, \"Aggregate Others\")\n",
    "    html.append(f\"\"\"\n",
    "    var ctxOthers = document.getElementById('othersRelsChart').getContext('2d');\n",
    "    var othersRelsChart = new Chart(ctxOthers, {{\n",
    "      type: 'line',\n",
    "      data: {{\n",
    "        labels: {main_labels_js},\n",
    "        datasets: [{others_rel_ds}]\n",
    "      }},\n",
    "      options: {{\n",
    "        responsive: true,\n",
    "        scales: {{\n",
    "          y: {{\n",
    "            min: -2,\n",
    "            max: 2,\n",
    "            ticks: {{\n",
    "              stepSize: 1\n",
    "            }}\n",
    "          }}\n",
    "        }}\n",
    "      }}\n",
    "    }});\n",
    "\"\"\")\n",
    "\n",
    "    # Orders chart\n",
    "    issued_js = \"[\" + \",\".join(str(x) for x in orders_issued_arr) + \"]\"\n",
    "    valid_js = \"[\" + \",\".join(str(x) for x in orders_valid_arr) + \"]\"\n",
    "    rej_js = \"[\" + \",\".join(str(x) for x in orders_rejected_arr) + \"]\"\n",
    "\n",
    "    html.append(f\"\"\"\n",
    "    var ctxOrders = document.getElementById('ordersChart').getContext('2d');\n",
    "    var ordersChart = new Chart(ctxOrders, {{\n",
    "      type: 'line',\n",
    "      data: {{\n",
    "        labels: {main_labels_js},\n",
    "        datasets: [\n",
    "          {{\n",
    "            label: 'Issued Orders',\n",
    "            data: {issued_js},\n",
    "            borderColor: 'red',\n",
    "            fill: false\n",
    "          }},\n",
    "          {{\n",
    "            label: 'Valid Orders',\n",
    "            data: {valid_js},\n",
    "            borderColor: 'green',\n",
    "            fill: false\n",
    "          }},\n",
    "          {{\n",
    "            label: 'Rejected Orders',\n",
    "            data: {rej_js},\n",
    "            borderColor: 'orange',\n",
    "            fill: false\n",
    "          }}\n",
    "        ]\n",
    "      }},\n",
    "      options: {{\n",
    "        responsive: true,\n",
    "        scales: {{\n",
    "          y: {{\n",
    "            beginAtZero: true\n",
    "          }}\n",
    "        }}\n",
    "      }}\n",
    "    }});\n",
    "\"\"\")\n",
    "\n",
    "    # If we have SVGs, include the JS to animate them\n",
    "    if svg_files:\n",
    "        js_code = \"\"\"\n",
    "    document.addEventListener('DOMContentLoaded', function() {\n",
    "        const svgFiles = SVG_FILES_PLACEHOLDER;\n",
    "        const phaseLabels = PHASE_LABELS_PLACEHOLDER;\n",
    "        let currentIndex = 0;\n",
    "        let isPlaying = false;\n",
    "        let playInterval = null;\n",
    "        const playbackSpeed = 1500;\n",
    "        const preloadedSVGs = [];\n",
    "        \n",
    "        const svgDisplay = document.getElementById('svgDisplay');\n",
    "        const prevBtn = document.getElementById('prevBtn');\n",
    "        const playPauseBtn = document.getElementById('playPauseBtn');\n",
    "        const nextBtn = document.getElementById('nextBtn');\n",
    "        const progressBar = document.getElementById('progressBar');\n",
    "        const progressContainer = document.getElementById('progressContainer');\n",
    "        const phaseLabel = document.getElementById('phaseLabel');\n",
    "        \n",
    "        svgDisplay.style.position = 'relative';\n",
    "        \n",
    "        function preloadSVGs() {\n",
    "            svgFiles.forEach((file, index) => {\n",
    "                const img = new Image();\n",
    "                img.src = file;\n",
    "                preloadedSVGs[index] = img;\n",
    "            });\n",
    "        }\n",
    "        \n",
    "        function initPlayer() {\n",
    "            if (svgFiles.length === 0) return;\n",
    "            preloadSVGs();\n",
    "            loadSVG(0);\n",
    "            updateControls();\n",
    "            \n",
    "            prevBtn.style.display = 'none';\n",
    "            nextBtn.style.display = 'none';\n",
    "            \n",
    "            playPauseBtn.addEventListener('click', togglePlayback);\n",
    "            progressContainer.addEventListener('click', handleProgressClick);\n",
    "        }\n",
    "        \n",
    "        function loadSVG(index) {\n",
    "            if (index < 0 || index >= svgFiles.length) return;\n",
    "            currentIndex = index;\n",
    "            const filePath = svgFiles[currentIndex];\n",
    "            \n",
    "            const newObj = document.createElement('object');\n",
    "            newObj.type = 'image/svg+xml';\n",
    "            newObj.data = filePath;\n",
    "            newObj.style.position = 'absolute';\n",
    "            newObj.style.top = 0;\n",
    "            newObj.style.left = 0;\n",
    "            newObj.style.width = '100%';\n",
    "            newObj.style.height = '100%';\n",
    "            newObj.style.opacity = '0';\n",
    "            \n",
    "            svgDisplay.appendChild(newObj);\n",
    "            \n",
    "            newObj.onload = function() {\n",
    "                newObj.style.transition = 'opacity 0.3s';\n",
    "                newObj.style.opacity = '1';\n",
    "                phaseLabel.textContent = phaseLabels[currentIndex];\n",
    "                const progress = (currentIndex / (svgFiles.length - 1)) * 100;\n",
    "                progressBar.style.width = progress + '%';\n",
    "                \n",
    "                updateControls();\n",
    "            };\n",
    "            \n",
    "            newObj.addEventListener('transitionend', function() {\n",
    "                Array.from(svgDisplay.children)\n",
    "                    .filter(child => child !== newObj)\n",
    "                    .forEach(child => svgDisplay.removeChild(child));\n",
    "            });\n",
    "        }\n",
    "        \n",
    "        function showPrevious() {\n",
    "            if (currentIndex > 0) {\n",
    "                loadSVG(currentIndex - 1);\n",
    "            }\n",
    "        }\n",
    "        \n",
    "        function showNext() {\n",
    "            if (currentIndex < svgFiles.length - 1) {\n",
    "                loadSVG(currentIndex + 1);\n",
    "            }\n",
    "        }\n",
    "        \n",
    "        function togglePlayback() {\n",
    "            isPlaying = !isPlaying;\n",
    "            if (isPlaying) {\n",
    "                playPauseBtn.textContent = '⏸️';\n",
    "                playInterval = setInterval(() => {\n",
    "                    if (currentIndex < svgFiles.length - 1) {\n",
    "                        loadSVG(currentIndex + 1);\n",
    "                    } else {\n",
    "                        clearInterval(playInterval);\n",
    "                        isPlaying = false;\n",
    "                        playPauseBtn.textContent = '▶️';\n",
    "                    }\n",
    "                }, playbackSpeed);\n",
    "            } else {\n",
    "                playPauseBtn.textContent = '▶️';\n",
    "                clearInterval(playInterval);\n",
    "            }\n",
    "        }\n",
    "        \n",
    "        function handleProgressClick(e) {\n",
    "            const rect = progressContainer.getBoundingClientRect();\n",
    "            const clickPosition = e.clientX - rect.left;\n",
    "            const containerWidth = rect.width;\n",
    "            const clickRatio = clickPosition / containerWidth;\n",
    "            const newIndex = Math.round(clickRatio * (svgFiles.length - 1));\n",
    "            loadSVG(newIndex);\n",
    "            //if (isPlaying) {\n",
    "            //    togglePlayback();\n",
    "            //}\n",
    "        }\n",
    "        \n",
    "        function updateControls() { }\n",
    "        \n",
    "        if (svgDisplay) {\n",
    "            initPlayer();\n",
    "        }\n",
    "        \n",
    "        var animationTabTrigger = document.getElementById('animation-tab');\n",
    "        if (animationTabTrigger) {\n",
    "            animationTabTrigger.addEventListener('shown.bs.tab', function(e) {\n",
    "                if (!isPlaying) {\n",
    "                    togglePlayback();\n",
    "                }\n",
    "            });\n",
    "            animationTabTrigger.addEventListener('hidden.bs.tab', function(e) {\n",
    "                if (isPlaying) {\n",
    "                    togglePlayback();\n",
    "                }\n",
    "            });\n",
    "        }\n",
    "    });\n",
    "    \"\"\"\n",
    "        svg_paths_js = \"[\" + \",\".join(f\"'{x}'\" for x in svg_files) + \"]\"\n",
    "        # We already built svg_phases_js\n",
    "        js_code = js_code.replace(\"SVG_FILES_PLACEHOLDER\", svg_paths_js)\n",
    "        js_code = js_code.replace(\"PHASE_LABELS_PLACEHOLDER\", svg_phases_js)\n",
    "        html.append(js_code)\n",
    "\n",
    "    html.append(\"\"\"\n",
    "</script>\n",
    "<script src=\"https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js\"></script>\n",
    "</body></html>\n",
    "\"\"\")\n",
    "\n",
    "    return \"\\n\".join(html)\n",
    "\n",
    "\n",
    "\n",
    "###############################################################################\n",
    "# 4) Main\n",
    "###############################################################################\n",
    "if __name__ == \"__main__\":\n",
    "    #run_id = 'o1-1.31'\n",
    "    #run_id = 'o3-mini-1.32'\n",
    "    #run_id = 'o3-mini-1.34'\n",
    "    #run_id = 'gemini-pro-1.5-1.35'\n",
    "    #run_id = 'claude-3.5-sonnet-20240620-1.36'\n",
    "    #run_id = 'claude-3.5-sonnet-1.39'\n",
    "    #run_id = 'grok-2-1212-1.42'\n",
    "    #run_id = 'gemini-2.0-flash-001-1.44'\n",
    "    #run_id = 'o3-mini-1.48'\n",
    "    #run_id = 'o1-1.50'\n",
    "    #run_id = 'gemini-2.0-flash-001-1.51'\n",
    "    #run_id = 'o3-mini-high-1.53'\n",
    "    #run_id = 'claude-3.7-sonnet-1.54'\n",
    "    run_id = 'deepseek-r1-1.56'\n",
    "    \n",
    "    infile = run_id + '.json'\n",
    "\n",
    "    with open(infile, \"r\", encoding=\"utf-8\") as f:\n",
    "        game_data = json.load(f)\n",
    "\n",
    "    # 1) Parse stats\n",
    "    stats_for_aut = parse_aut_statistics(game_data)\n",
    "\n",
    "    # 2) Parse negotiations (with the same data we have about phases so we can label them)\n",
    "    aut_negs = parse_aut_negotiations(game_data, stats_for_aut)\n",
    "\n",
    "    # 3) Generate HTML\n",
    "    html_report = generate_html_report(game_data, stats_for_aut, aut_negs)\n",
    "\n",
    "    # 4) Write out\n",
    "    outfile = run_id + '.html'\n",
    "    with open(outfile, \"w\", encoding=\"utf-8\") as f:\n",
    "        f.write(html_report)\n",
    "\n",
    "    print(f\"HTML report generated: {outfile}\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}