import ast
import json
from pathlib import Path
import sys
import unittest
ROOT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(ROOT))
from completion import prompt,prefix,assemble,PROMPT_VERSION
from validators.dataset import load

class CompletionTests(unittest.TestCase):
    def setUp(self):self.rows=load(ROOT/'data/smolscript.jsonl')
    def test_prompt_ends_with_header_and_never_reads_answers(self):
        for row in self.rows:
            text=prompt(row)
            self.assertTrue(text.endswith(prefix(row)))
            if row['language'] not in ('html','css'):
                self.assertTrue(prefix(row).endswith('\n'))
                self.assertFalse(text.endswith((' ', '\t')))
            changed={**row,'reference_solution':'SECRET_REFERENCE','tests':[{'input':'SECRET_INPUT','expected':'SECRET_ANSWER'}]}
            self.assertEqual(prompt(changed),text)
            self.assertNotIn('Return code only',text)
            self.assertNotIn('function function',text)
    def test_python_has_no_type_annotation_boilerplate(self):
        row=next(r for r in self.rows if r['language']=='python')
        self.assertEqual(prefix(row),'def solve(n):\n')
        text=assemble(row,'    return abs(2*n)%10\n\nQuestion: explain this code')
        ast.parse(text);self.assertNotIn('Question:',text)
    def test_every_reference_body_roundtrips_without_solution_repairs(self):
        refs={r['id']:r['reference_solution'] for r in load(ROOT/'references/solutions.jsonl')}
        for row in self.rows:
            lang=row['language'];ref=refs[row['id']]
            if lang=='html':tail=ref[1:]
            elif lang=='css':tail=ref
            elif lang=='python':tail=ref.split('\n',1)[1]
            else:
                self.assertTrue(ref.startswith(prefix(row)),row['id'])
                tail=ref[len(prefix(row)):]
            result=assemble(row,tail)
            if lang=='python':
                self.assertEqual(ast.dump(ast.Module(body=ast.parse(ref).body[0].body,type_ignores=[])),ast.dump(ast.Module(body=ast.parse(result).body[0].body,type_ignores=[])),row['id'])
                self.assertEqual(len(ast.parse(ref).body[0].body),len(ast.parse(result).body[0].body),row['id'])
            else:self.assertEqual(result,ref.rstrip()+'\n',row['id'])
    def test_scopes_ignore_strings_and_preserve_nested_blocks(self):
        row=next(r for r in self.rows if r['language']=='javascript' and r['metadata']['family']=='scalar')
        code=assemble(row,'if (n) { return "}"; }\n    return 0;\n}\nExplanation: done')
        self.assertIn('return 0;',code);self.assertNotIn('Explanation',code)
    def test_delimiters_inside_regex_raw_and_verbatim_strings(self):
        cases=[('javascript','return /[{}]/.test("}");\n}'),
               ('cpp','return std::string(R"tag(} \" {)tag");\n}'),
               ('csharp','return @"a "" } "" b";\n}\n}')]
        for lang,tail in cases:
            row=next(r for r in self.rows if r['language']==lang)
            self.assertEqual(assemble(row,tail+'\nExplanation: done'),prefix(row)+tail+'\n',lang)

    def test_truncated_body_is_not_given_missing_braces(self):
        row=next(r for r in self.rows if r['language']=='javascript')
        self.assertFalse(assemble(row,'return 3;').rstrip().endswith('}'))
    def test_python_continuation_can_define_a_module_helper(self):
        row=next(r for r in self.rows if r['language']=='python')
        body='    return double(n)\n\ndef double(x):\n    return 2*x\n'
        code=assemble(row,body)
        self.assertEqual([node.name for node in ast.parse(code).body],['solve','double'])
        self.assertEqual(code,prefix(row)+body)

    def test_complete_function_and_fenced_output_are_accepted(self):
        row=next(r for r in self.rows if r['language']=='python')
        whole='def solve(n):\n    return abs(n)\n'
        self.assertEqual(assemble(row,whole),whole)
        self.assertEqual(assemble(row,'```python\n    return abs(n)\n```'),whole)
        self.assertIn('return "```"',assemble(row,'```python\n    return "```"\n```'))
        self.assertIn('return "```"',assemble(row,'    return "```"'))
        self.assertEqual(assemble(row,'```python\n'+whole+'```'),whole)
        with self.assertRaises(ValueError):assemble(row,'```python\nreturn n')

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