"""Static-index correctness tests independent of the original payload corpus."""
import hashlib
from pathlib import Path
import tempfile
import unittest

import map_references as mapper


class LexicalMappingTests(unittest.TestCase):
    def test_comments_and_literals_do_not_become_dependencies(self):
        source = '''// #include "fake1.ixpl"
/* C::loadConfigFile("bad.cfg"); */
string x = "C::fake(1)";
string raw = \\"[\n#include "fake2.ixpl"\nC::fake(2);\n]";
#include "Core.ixpl"
namespace C = Core;
void real() { C::loadConfigFile("real.cfg", cfg); }
'''
        report = mapper.scan_ixpl(source)
        self.assertEqual([(x['include'],x['line']) for x in report['includes']], [('Core.ixpl',8)])
        self.assertEqual([(c['qualifier'],c['method']) for c in report['qualified_calls']], [('Core','loadConfigFile')])

    def test_balanced_call_arguments_and_opaque_commas(self):
        source = 'namespace C = Core;\nvoid f() { C::queueTask(id, int[]{1, 2}, nested(3, 4), "x,y"); }'
        call = mapper.scan_ixpl(source)['qualified_calls'][0]
        self.assertEqual(call['arguments'],['id','int[]{1, 2}','nested(3, 4)','"x,y"'])

    def test_interrupt_overloads_keep_signatures_and_source_lines(self):
        source = ('int INT_A = 7;\nvoid get(int &x);\n'
                  'void get(int &x) interrupt(+INT_A, x);\n'
                  'int get() {int x; interrupt(+INT_A, x); return x;}\n')
        wrappers = mapper.scan_ixpl(source)['interrupt_wrappers']
        self.assertEqual([w['wrapper']['signature'] for w in wrappers],['void get(int &x)','int get()'])
        self.assertEqual([w['line'] for w in wrappers],[3,4])
        self.assertEqual(mapper.constant_value(wrappers[0]['arguments'][0],{'INT_A':7}),7)

    def test_historical_struct_return_is_not_attached_to_previous_wrapper(self):
        source = ('type Brush = (int x);\nvoid deselect(int x) interrupt(+1,x);\n'
                  'Brush &read() {Brush b; interrupt(+2,b); return b;}\n')
        wrappers=mapper.scan_ixpl(source)['interrupt_wrappers']
        self.assertEqual(wrappers[1]['wrapper']['name'],'read')
        self.assertEqual(wrappers[1]['wrapper']['line'],3)
        self.assertEqual(wrappers[1]['line'],3)

    def test_numeric_resolution_is_not_code_execution(self):
        self.assertEqual(mapper.constant_value('_INT_BEGIN + 5',{'_INT_BEGIN':249}),254)
        for value in ['__import__("os").system("bad")','X + 1','2 * 3']:
            with self.subTest(value=value), self.assertRaises(ValueError):
                mapper.constant_value(value,{})

    def test_literal_names_resolve_only_unambiguous_bindings(self):
        report = mapper.scan_ixpl('string prefix = "camera.";\nstring name = prefix+"toggle";')
        self.assertEqual(mapper.literal_string('name',report['string_bindings']),'camera.toggle')
        for value in ['missing','"bad"+','call()']:
            self.assertIsNone(mapper.literal_string(value,report['string_bindings']))
        self.assertIsNone(mapper.literal_string('prefix',{'prefix':[{'expression':'"a"'},{'expression':'"b"'}]}))
        self.assertIsNone(mapper.literal_string('cycle',{'cycle':[{'expression':'cycle'}]}))

    def test_large_multiline_literal_is_opaque(self):
        source = 'string data = \\"[' + (' ' * 1000 + '\n') * 80 + ']";\nvoid f() { Core::undo(); }'
        self.assertEqual(mapper.scan_ixpl(source)['qualified_calls'][0]['method'],'undo')
        for source in ['/* unterminated','string s = "bad','string s = \\"[bad']:
            with self.assertRaises(ValueError):mapper.lex(source)

    def test_build_graph_reports_missing_and_ambiguous_candidates(self):
        with tempfile.TemporaryDirectory() as temp:
            root = Path(temp).resolve()
            content = {'tools/includePaths.txt':b'..\\inc1\n..\\inc2\n',
                       'inc1/Core.ixpl':b'namespace Core {}', 'inc2/Core.ixpl':b'namespace Core {}',
                       'data/sources/plugins/tool.ixpl':b'#include "Core.ixpl"\n#include "Missing.ixpl"\n'}
            inventory = {'build':'synthetic','archive_sha256':'a'*64,'files':[]}
            for name,raw in content.items():
                path=root/name;path.parent.mkdir(parents=True,exist_ok=True);path.write_bytes(raw)
                inventory['files'].append({'path':name,'sha256':hashlib.sha256(raw).hexdigest()})
            build = mapper.index_build(root,inventory)
            plugin = next(f for f in build['files'] if f['category']=='plugin')
            self.assertEqual([e['status'] for e in plugin['includes']],['ambiguous','missing'])
            (root/'inc1/Core.ixpl').write_bytes(b'changed')
            with self.assertRaises(ValueError):mapper.index_build(root,inventory)

    def test_diffs_distinguish_renames_copies_and_changes(self):
        old={'build':'a','files':[{'path':'old.txt','sha256':'1'},{'path':'retained.txt','sha256':'2'}]}
        new={'build':'b','files':[{'path':'new.txt','sha256':'1'},{'path':'retained.txt','sha256':'2'}, {'path':'copy.txt','sha256':'2'}]}
        diff=mapper.differences([old,new])[0]
        self.assertEqual(diff['identical_rename_candidates'],[{'from':'old.txt','to':'new.txt'}])
        self.assertEqual(diff['identical_copy_candidates'],[{'from':'retained.txt','to':'copy.txt'}])