import json
import tempfile
import time
import unittest
from pathlib import Path
from PIL import Image

import numpy as np
from hud_alpha import clear_world_alpha, clear_supplemental_hud_alpha
from run_bridge import (decode_state_line, translate_command, full_screen_capture,
                        remove_enemy_hud, native_window_frame, remove_pause_overlay,
                        FRAME_HEADER, raw_frame_bytes, FramePublisher)


class BridgeTests(unittest.TestCase):
    def test_empty_native_drone_equipment_does_not_erase_weapons(self):
        weapons=[{'slot':0,'name':'MISSILES_2','title':'Artemis Missiles','ammo_cost':1},
                 {'slot':1,'name':'LASER_BURST_3','title':'Burst Laser Mark II','ammo_cost':0}]
        raw={'protocol':2,'source':'hyperspace','ready':True,
             'player':{'weapons':weapons,'drone_equipment':{},'crew':{},'drones':{}}}
        normalized=decode_state_line('FTLVR_STATE '+json.dumps(raw))
        self.assertEqual(normalized['player']['drone_equipment'],[])
        self.assertEqual(normalized['player']['weapons'],weapons)

    def test_raw_transport_keeps_dimensions_rgba_orientation_and_timestamp(self):
        image=Image.new('RGBA',(960,540),(10,20,30,40))
        image.putpixel((0,0),(1,2,3,4));image.putpixel((0,539),(5,6,7,8))
        raw=raw_frame_bytes(image,12,123.5)
        self.assertEqual(FRAME_HEADER.size,36)
        self.assertEqual(FRAME_HEADER.unpack(raw[:36]),(b'FVR1',1,960,540,4,12,123.5))
        self.assertEqual(len(raw),36+960*540*4)
        self.assertEqual(raw[36:40],bytes((1,2,3,4)))
        self.assertEqual(raw[36+539*960*4:40+539*960*4],bytes((5,6,7,8)))

    def test_independent_raw_streams_publish_without_waiting_for_png_preview(self):
        with tempfile.TemporaryDirectory() as directory:
            publisher=FramePublisher(Path(directory))
            image=Image.new('RGBA',(16,9),(10,20,30,40))
            try:
                for i in range(8):publisher.publish('screen_frame',image,float(i))
                publisher.publish('hud_frame',image,8.)
                raw=(Path(directory)/'screen_frame.rgba').read_bytes()
                self.assertEqual(FRAME_HEADER.unpack(raw[:36])[-2:],(8,7.))
                self.assertTrue((Path(directory)/'hud_frame.rgba').exists())
                deadline=time.monotonic()+1
                while not (Path(directory)/'hud_frame.png').exists() and time.monotonic()<deadline:time.sleep(.01)
                self.assertTrue((Path(directory)/'hud_frame.png').exists())
            finally:publisher.close()

    def test_jump_and_pending_events_never_become_full_screen(self):
        base={'ready':True,'ui_mode':'screen'}
        self.assertFalse(full_screen_capture(base))
        for key in ('transition','event_pending','event_open','map_open','tactical'):
            self.assertFalse(full_screen_capture(dict(base,**{key:True})),key)
        self.assertTrue(full_screen_capture({'ready':False,'ui_mode':'menu'}))
        self.assertTrue(full_screen_capture({'ready':True,'ui_mode':'menu'}))
        self.assertFalse(full_screen_capture(dict(base,panel_open=True,panel_kind='shop')))

    def test_in_run_modal_window_never_duplicates_on_full_headset_screen(self):
        for kind in ('ship', 'window', 'options', 'sell'):
            with self.subTest(kind=kind):
                self.assertFalse(full_screen_capture({'ready':True,'ui_mode':'menu',
                                                     'panel_open':True,'panel_kind':kind}))
        self.assertTrue(full_screen_capture({'ready':False,'ui_mode':'menu','panel_open':True}))

    def test_enemy_frame_removed_without_touching_player_widgets(self):
        pixels=np.full((720,1280,4),255,dtype=np.uint8)
        result=remove_enemy_hud(pixels)
        self.assertEqual(result[48,879,3],0)
        self.assertEqual(result[588,1273,3],0)
        self.assertEqual(result[590,1279,3],0,'Right-edge target separator must never survive')
        self.assertEqual(result[605,1150,3],255,'Player subsystem strip must remain')
        self.assertEqual(result[100,70,3],255)
        self.assertTrue(np.array_equal(result[:,:,:3],pixels[:,:,:3]))

    def test_window_frame_keeps_native_black_ink_and_discards_hud(self):
        pixels=np.zeros((720,1280,4),dtype=np.uint8)
        pixels[120:610,300:980,:3]=[120,180,190]
        pixels[135:595,315:965,:3]=0
        pixels[40:75,20:280,:3]=[100,200,180]
        result=native_window_frame(pixels)
        self.assertEqual(result[360,640,3],255)
        self.assertEqual(result[120,300,3],255)
        self.assertEqual(result[50,70,3],0)

    def test_sell_drop_box_and_item_tooltip_are_retained(self):
        pixels=np.zeros((720,1280,4),dtype=np.uint8)
        pixels[100:600,340:940,:3]=[160,190,185]
        pixels[115:585,355:925,:3]=0
        pixels[190:385,65:325,:3]=[160,190,185]
        pixels[202:372,77:313,:3]=0
        pixels[160:280,945:1265,:3]=[160,190,185]
        pixels[172:268,957:1253,:3]=0
        pixels[155:190,5:95,:3]=[20,36,30]
        pixels[610:710,240:650,:3]=[100,180,150]
        result=native_window_frame(pixels)
        self.assertEqual(result[300,195,3],255,'Native SELL drop target must remain visible')
        self.assertEqual(result[200,1100,3],255,'Native item tooltip must remain visible')
        self.assertEqual(result[200,50,3],0,'Separate crew HUD must be removed')
        self.assertEqual(result[640,400,3],0,'Separate weapon HUD must be removed')
        self.assertEqual(result[650,640,3],0)
        self.assertTrue(np.array_equal(result[:,:,:3],pixels[:,:,:3]))
        pixels[120:610,300:980,:3]=0
        self.assertFalse(np.any(native_window_frame(pixels)[:,:,3]))

    def test_sell_window_survives_transparent_center_and_separate_content(self):
        pixels=np.zeros((720,1280,4),dtype=np.uint8)
        pixels[120:126,300:980,:3]=[120,170,175]
        pixels[120:610,300:306,:3]=[120,170,175]
        pixels[120:610,974:980,:3]=[120,170,175]
        pixels[604:610,300:600,:3]=[120,170,175]
        pixels[420:450,600:700,:3]=[220,200,180]
        pixels[30:75,20:280,:3]=[100,200,180]
        result=native_window_frame(pixels)
        self.assertEqual(result[360,640,3],0)
        self.assertEqual(result[120,300,3],255)
        self.assertEqual(result[430,650,3],255)
        self.assertEqual(result[50,70,3],0)

    def test_cached_native_pause_glyph_is_removed_without_cutting_controls(self):
        pixels=np.full((720,1280,4),255,dtype=np.uint8)
        result=remove_pause_overlay(pixels)
        self.assertEqual(result[552,640,3],0)
        self.assertEqual(result[620,640,3],255)
        self.assertEqual(result[400,70,3],255)

    def test_panel_open_gap_does_not_retain_dim_native_pause_glyph(self):
        pixels=np.zeros((720,1280,4),dtype=np.uint8)
        pixels[100:550,340:930,:3]=[170,210,200]
        pixels[115:535,355:915,:3]=0
        pixels[540:598,790:915,:3]=[170,210,200]
        pixels[553:585,803:902,:3]=0
        pixels[560:577,550:730,:3]=[26,39,42]
        result=native_window_frame(pixels)
        self.assertFalse(np.any(result[560:577,550:730,3]))
        self.assertEqual(result[570,850,3],255,'Native close button ink must remain')

    def test_native_text_entry_requires_active_context_and_uses_text_events(self):
        state={'text_entry':{'active':True,'id':'entry-3','text':'Kestrel','max_length':16}}
        command={'action':'text_input','data':{'entry_id':'entry-3','op':'insert','text':'A é'}}
        result=translate_command(command,state)
        self.assertEqual([x['codepoint'] for x in result],[65,32,233])
        self.assertTrue(all(x['type']=='text' and x['entry_id']=='entry-3' for x in result))
        for op,value in [('backspace',3),('confirm',0)]:
            command['data']={'entry_id':'entry-3','op':op}
            self.assertEqual(translate_command(command,state)[0]['event'],value)
        command['data']={'entry_id':'entry-3','op':'cancel'}
        self.assertEqual(translate_command(command,state)[0]['type'],'text_cancel')
        command['data']['entry_id']='entry-2'
        with self.assertRaises(ValueError):translate_command(command,state)
        for entry_id in (None, ''):
            command['data']['entry_id']=entry_id
            with self.assertRaises(ValueError):translate_command(command,state)
        command['data'].pop('entry_id')
        with self.assertRaises(ValueError):translate_command(command,state)
        state['text_entry']['active']=False
        command['data']['entry_id']='entry-3'
        with self.assertRaises(ValueError):translate_command(command,state)

    def test_door_uses_native_center_and_rejects_locked_or_enemy_door(self):
        state={'ready':True,'ui_mode':'game','player_origin':{'x':380,'y':116},
               'player':{'doors':[{'id':4,'x':175,'y':192,'controllable':True}]}}
        command={'action':'door_toggle','data':{'door_id':4,'ship':'player'}}
        result=translate_command(command,state)
        self.assertEqual((result[0]['x'],result[0]['y']),(555,308))
        self.assertEqual(result[0]['phase'],'click')
        state['player']['doors'][0]['controllable']=False
        with self.assertRaises(ValueError): translate_command(command,state)
        command['data']['ship']='enemy'
        with self.assertRaises(ValueError): translate_command(command,state)

    def test_drone_render_space_is_independent_of_owning_ship(self):
        raw={'protocol':2,'source':'hyperspace',
             'player':{'drones':[{'id':'9','owner':0,'space':1,'is_space':True}]},
             'enemy':{'drones':{}}}
        state=decode_state_line('FTLVR_STATE '+json.dumps(raw))
        self.assertEqual(state['player']['drones'],[])
        self.assertEqual(state['enemy']['drones'][0]['owner'],0)
        self.assertEqual(state['player']['doors'],[])

    def test_event_wheel_rejects_stale_and_disabled_choices(self):
        state={'ready':True,'ui_mode':'game','event_open':True,
               'dialog':{'id':'7','choices':[{'enabled':True},{'enabled':False}]}}
        command={'action':'event_choice','data':{'index':0,'dialog_id':'7'}}
        self.assertEqual(translate_command(command,state)[0]['key'],49)
        command['data']['dialog_id']='6'
        with self.assertRaises(ValueError): translate_command(command,state)
        command['data'].update(dialog_id='7',index=1)
        with self.assertRaises(ValueError): translate_command(command,state)
        with self.assertRaises(ValueError): translate_command({'action':'select_crew','data':{'crew_id':'crew-1'}},state)

    def test_modifiers_reach_every_input_phase(self):
        commands=translate_command({'action':'ui_mouse','data':{'x':70,'y':30,'phase':'down',
            'modifiers':{'shift':True,'control':True}}},{})
        self.assertEqual(commands[0]['modifiers'],{'shift':True,'control':True})
        self.assertEqual(translate_command({'action':'key','data':{'key':49}}, {})[0]['modifiers'],
            {'shift':False,'control':False})
        with self.assertRaises(ValueError):
            translate_command({'action':'key','data':{'key':49,'modifiers':{'alt':True}}},{})

    def test_unavailable_navigation_is_rejected(self):
        state={'ready':True,'ui_mode':'game','navigation':{'jump':True,'store':False},
               'jump_button':{'x':530,'y':20}}
        with self.assertRaises(ValueError): translate_command({'action':'navigate','data':{'screen':'store'}},state)
        self.assertEqual(translate_command({'action':'navigate','data':{'screen':'jump'}},state)[0]['x'],555)

    def test_alpha_preserves_enclosed_black_ui_ink_and_rgb(self):
        pixels=np.zeros((20,30,4),dtype=np.uint8)
        pixels[4:16,6:24,:3]=[125,180,190]
        pixels[7:12,10:16,:3]=0
        result=clear_world_alpha(pixels)
        self.assertEqual(result[0,0,3],0)
        self.assertEqual(result[9,12,3],255)
        self.assertTrue(np.array_equal(result[:,:,:3],pixels[:,:,:3]))

    def test_supplemental_warning_keeps_text_and_native_faint_shadow_coverage(self):
        pixels=np.zeros((720,1280,4),dtype=np.uint8)
        # Native warning glyphs with a barely visible red-black texture fringe.
        pixels[210:270,675:785]=[1,0,0,2]
        pixels[215:223,690:770]=[86,18,10,43]
        pixels[235:243,683:777]=[86,18,10,43]
        pixels[255:263,683:777]=[86,18,10,43]
        result=clear_supplemental_hud_alpha(pixels)
        self.assertEqual(result[212,680,3],2,'Warning shadow must retain its faint native alpha')
        self.assertEqual(result[218,700,3],255,'Native warning text must retain its existing visibility')
        self.assertTrue(np.array_equal(result[:,:,:3],pixels[:,:,:3]))

    def test_supplemental_warning_fade_and_scaled_native_capture(self):
        pixels=np.zeros((720,1280,4),dtype=np.uint8)
        pixels[210:270,675:785]=[1,0,0,1]
        pixels[216:222,690:770]=[20,4,2,1]
        for sample in (pixels,pixels[::2,::2]):
            result=clear_supplemental_hud_alpha(sample)
            scale=pixels.shape[0]//sample.shape[0]
            self.assertEqual(result[212//scale,680//scale,3],1)
            self.assertEqual(result[218//scale,700//scale,3],255,'Faded warning glyph RGB must not be multiplied by raw alpha twice')
            self.assertTrue(np.array_equal(result[:,:,:3],sample[:,:,:3]))

    def test_supplemental_warning_conversion_preserves_controls_and_normal_frames(self):
        pixels=np.zeros((720,1280,4),dtype=np.uint8)
        pixels[15:65,15:200,:3]=[125,180,190]
        pixels[25:55,25:190,:3]=0
        pixels[620:690,295:700,:3]=[125,180,190]
        pixels[632:678,307:688,:3]=0
        pixels[212:222,345:355]=[1,0,0,2]
        pixels[190:200,610:760]=[1,0,0,2]
        pixels[195:198,640:690]=[150,180,190,255]
        expected=clear_world_alpha(pixels)
        result=clear_supplemental_hud_alpha(pixels)
        self.assertTrue(np.array_equal(result,expected),'A normal HUD must keep the legacy control alpha')
        self.assertEqual(result[40,70,3],255,'Black ink inside top controls must remain opaque')
        self.assertEqual(result[650,640,3],255,'Black weapon panel ink must remain opaque')

    def test_empty_lua_vectors_become_arrays(self):
        state=decode_state_line('FTLVR_STATE '+json.dumps({'protocol':2,'source':'hyperspace',
            'shots':{},'projectiles':{},'player':{'rooms':{},'crew':{},'weapons':{}}}))
        self.assertEqual(state['player']['crew'],[])
        self.assertEqual(state['shots'],[])

    def test_native_target_points_survive_empty_lua_vectors(self):
        targets=[{'x':102,'y':134},{'x':177,'y':134}]
        raw={'protocol':2,'source':'hyperspace','player':{'weapons':[
            {'slot':0,'targets':{},'target_ship':1},
            {'slot':1,'targets':targets,'target_ship':1}]}}
        state=decode_state_line('FTLVR_STATE '+json.dumps(raw))
        self.assertEqual(state['player']['weapons'][0]['targets'],[])
        self.assertEqual(state['player']['weapons'][1]['targets'],targets)

    def test_native_room_target_includes_enemy_screen_offset(self):
        state={'ready':True,'ui_mode':'game','combat':True,'weapon_selected':1,
            'enemy_origin':{'x':953,'y':105},
            'enemy':{'rooms':[{'id':3,'center':{'x':70,'y':192}}]}}
        result=translate_command({'action':'target_room','data':{'room_id':3}},state)
        self.assertEqual((result[0]['x'],result[0]['y']),(1023,297))
        state['weapon_selected']=-1
        with self.assertRaises(ValueError): translate_command({'action':'target_room','data':{'room_id':3}},state)

    def test_targeted_systems_and_tactical_use_native_room_inputs(self):
        state={'ready':True,'ui_mode':'screen','tactical':True,'combat':True,'weapon_selected':-1,
               'enemy_origin':{'x':950,'y':105},'player_origin':{'x':380,'y':115},
               'enemy':{'rooms':[{'id':3,'center':{'x':70,'y':192}}]},
               'player':{'rooms':[{'id':5,'center':{'x':175,'y':157}}]}}
        command={'action':'target_room','data':{'room_id':3,'ship':'enemy'}}
        for kind in ('mind','hacking','teleporter','weapon'):
            state['targeting']={'active':True,'kind':kind,'ships':['enemy']}
            result=translate_command(command,state)
            self.assertEqual((result[0]['x'],result[0]['y']),(1020,297))
            self.assertEqual(result[0]['type'],'mouse')
        state['targeting']={'active':True,'kind':'mind','ships':['player','enemy']}
        command['data']={'room_id':5,'ship':'player'}
        self.assertEqual(translate_command(command,state)[0]['x'],555)
        state['blocking_ui']=True
        with self.assertRaises(ValueError):translate_command(command,state)
        state['blocking_ui']=False;state['map_open']=True
        with self.assertRaises(ValueError):translate_command(command,state)
        state['map_open']=False;state['targeting']['active']=False
        with self.assertRaises(ValueError):translate_command(command,state)

    def test_system_power_uses_native_icons_and_never_forces_modifiers(self):
        state={'ready':True,'ui_mode':'screen','tactical':True,
               'player':{'system_status':[{'id':0,'key':'shields','powerable':True,
                   'power_button':{'x':90,'y':684}},{'id':8,'key':'doors','powerable':False}]}}
        command={'action':'system_power','data':{'system_id':0,'direction':1,
                                                'modifiers':{'shift':True,'control':True}}}
        result=translate_command(command,state)[0]
        self.assertEqual((result['x'],result['y'],result['button']),(90,684,'left'))
        self.assertEqual(result['modifiers'],{'shift':False,'control':False})
        command['data']={'system_key':'shields','direction':-1}
        self.assertEqual(translate_command(command,state)[0]['button'],'right')
        for data in ({'system_id':8,'direction':1},{'system_id':0,'direction':0}):
            command['data']=data
            with self.assertRaises(ValueError):translate_command(command,state)
        state['player']['system_status'][0].pop('power_button')
        command['data']={'system_id':0,'direction':1}
        with self.assertRaises(ValueError):translate_command(command,state)

    def test_ui_bounds_and_hotkey_whitelist(self):
        with self.assertRaises(ValueError): translate_command({'action':'ui_mouse','data':{'x':1280,'y':3}}, {})
        with self.assertRaises(ValueError): translate_command({'action':'key','data':{'key':9999}}, {})

    def test_boarding_crew_uses_current_ship_not_ownership(self):
        raw={'protocol':2,'source':'hyperspace','ready':True,'ui_mode':'game',
            'player':{'crew':[{'id':'crew-1','owner':0,'ship':1,'controllable':True,'x':70,'y':175}]},
            'enemy':{'rooms':[{'id':3,'center':{'x':70,'y':192}}]},
            'enemy_origin':{'x':953,'y':105}}
        state=decode_state_line('FTLVR_STATE '+json.dumps(raw))
        self.assertEqual(state['player']['crew'],[])
        self.assertEqual(state['enemy']['crew'][0]['owner'],0)
        commands=translate_command({'action':'move_crew','data':{'crew_id':'crew-1','room_id':3}},state)
        self.assertEqual((commands[-1]['x'],commands[-1]['y']),(1023,297))
        self.assertEqual(commands[-1]['button'],'right')


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