# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
import gzip
import json
from pathlib import Path
import tempfile
import unittest
import numpy as np

import prepare as p
from alignment import pair, sglang_groups, vllm_groups


def record(rank, timestamp, counter=0):
    return {"version": 1, "worker_id": "test", "dp_rank": rank, "counter_id": counter,
            "wall_time": .01, "received_at_ns": timestamp, "source_line": counter + rank + 1,
            "scheduled_requests": {"num_prefill_requests": 0, "num_decode_requests": 1},
            "queued_requests": {"num_prefill_requests": 0, "num_decode_requests": 0}}


class PrepareTests(unittest.TestCase):
    def test_timezone(self):
        self.assertEqual(p.epoch_ns("2026-09-09T17:06:12.297086", "America/Los_Angeles"),
                         p.epoch_ns("2026-09-10T00:06:12.297086", "UTC"))

    def test_aware_time_not_relocalized(self):
        self.assertEqual(p.epoch_ns("2026-09-10T00:06:12.297086+00:00", "America/Los_Angeles"),
                         p.epoch_ns("2026-09-10T00:06:12.297086", "UTC"))

    def test_drain_not_in_window(self):
        export = {"start_time": "2026-09-10T00:00:00", "end_time": "2026-09-10T01:00:40",
                  "input_config": {"phases": [{"kind": "profiling", "duration": 3600}]}}
        start, end = p.measured_window(export, "UTC")
        self.assertEqual(end-start, 3600*10**9)
        self.assertEqual(end, p.epoch_ns("2026-09-10T01:00:00", "UTC"))

    def test_exact_integer_nanoseconds(self):
        self.assertEqual(p.epoch_ns("2026-09-11T00:06:24.700077", "UTC"),1789085184700077000)

    def test_sequence_join_crosses_receive_delay_and_skips_missing_step(self):
        rng=np.random.default_rng(42)
        walls=rng.uniform(.02,.10,100)
        times=np.cumsum(walls)
        a=np.column_stack((times,walls))
        kept=np.array([i for i in range(100) if i not in (15,41)])
        b=np.column_stack((times[kept]+.040,walls[kept]+.000002))
        result,_,_=pair(a,b)
        expected=np.full(100,-1)
        expected[kept]=np.arange(len(kept))
        np.testing.assert_array_equal(result,expected)

    def test_sglang_validated_ordinal_not_receive_window(self):
        rng=np.random.default_rng(42)
        walls=rng.uniform(.02,.10,100)
        rows=[];ordinals={}
        for rank in (0,1):
            for i in range(3,9):
                row=record(rank,1789085184700077000+i*10**8+rank*500_000_000,i)
                row['source_line']=rank*100+i
                row['wall_time']=float(walls[i]+rank*.000002)
                rows.append(row);ordinals[row['source_line']]=i
        groups,audit=sglang_groups(rows,[0,1],{0:walls,1:walls+.000002},ordinals)
        self.assertEqual(len(groups),6)
        for members,support in groups:
            self.assertEqual([r['dp_rank'] for r in members],[0,1])
            self.assertEqual(members[0]['counter_id'],members[1]['counter_id'])
            self.assertEqual(members[1]['received_at_ns']-members[0]['received_at_ns'],500_000_000)

    def test_sglang_unequal_counts_fail_closed(self):
        with self.assertRaises(ValueError):
            sglang_groups([], [0,1], {0:[.01,.02],1:[.01]}, {})

    def test_prefill_duration_difference_keeps_sequence_match(self):
        rng=np.random.default_rng(42)
        walls=rng.uniform(.02,.10,100)
        walls[50]=.25
        times=np.cumsum(walls)
        other=walls.copy();other[50]=.28
        result,_,_=pair(np.column_stack((times,walls)),np.column_stack((times+.001,other)))
        self.assertEqual(result[50],50)

    def test_multi_reference_membership_is_unique_and_lossless(self):
        rng=np.random.default_rng(42)
        walls=rng.uniform(.02,.10,100)
        times=np.cumsum(walls)
        rows=[]
        for rank in (0,1,2):
            for i in range(100):
                if rank==2 and i==30:
                    continue
                row=record(rank,int((times[i]+rank*.020)*1e9),i)
                row['source_line']=rank*100+i+1
                row['wall_time']=float(walls[i]+rank*.000002)
                rows.append(row)
        groups,report=vllm_groups(rows,[0,1,2])
        actual=[r['source_line'] for group,_ in groups for r in group]
        self.assertEqual(sorted(actual),sorted(r['source_line'] for r in rows))
        self.assertEqual(len(actual),len(set(actual)))
        self.assertEqual(sum(len(g)==3 for g,_ in groups),99)

    def test_plain_list_of_lists_and_deterministic_gzip(self):
        values = [[record(0, 0)], [record(0, 10, 1), record(1, 11, 1)]]
        with tempfile.TemporaryDirectory() as d:
            files = [Path(d) / name for name in ("a.gz", "b.gz")]
            for path in files:
                with p.gzip_text(path) as f:
                    f.write(b"[\n")
                    for i, group in enumerate(values):
                        p.emit_array_item(f, group, i)
                    f.write(b"\n]\n")
                with gzip.open(path, "rt") as f:
                    self.assertEqual(json.load(f), values)
                self.assertEqual(list(p.read_groups(path)), values)
            self.assertEqual(files[0].read_bytes(), files[1].read_bytes())

    def test_empty_list(self):
        with tempfile.TemporaryDirectory() as d:
            path = Path(d) / "a.gz"
            with p.gzip_text(path) as f:
                f.write(b"[\n\n]\n")
            self.assertEqual(list(p.read_groups(path)), [])

    def test_invalid_metric_rejected(self):
        row = record(0, 0)
        row["wall_time"] = float("nan")
        with self.assertRaises(ValueError):
            p.check_record(row, [0])


if __name__ == "__main__":
    unittest.main()