import inspect
import pytest
 
import sys 
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from slic.utils.argfwd import *

@pytest.mark.parametrize("lst, index, expected", [
    (['a', 'b', 'c', 'd'], 2, (['a', 'b'], ['c', 'd'])),
    (['x', 'y'], 1, (['x'], ['y'])),
    ([], 0, ([], [])),
])
def test_split_at(lst, index, expected):
    assert split_at(lst, index) == expected


@pytest.mark.parametrize("a, b, expected", [
    (['a', 'b'], ['b', 'c'], ['a', 'b', 'c']),
    ([], ['x'], ['x']),
    (['x', 'y'], ['x', 'y'], ['x', 'y']),
])
def test_merge_lists_unique(a, b, expected):
    assert merge_lists_unique(a, b) == expected


@pytest.mark.parametrize("a, b, expected", [
    ({'a': 1}, {'b': 2}, {'a': 1, 'b': 2}),
    ({'x': 1}, {'x': 9, 'y': 3}, {'x': 1, 'y': 3}),
    ({}, {'k': 4}, {'k': 4}),
])
def test_merge_dicts_unique(a, b, expected):
    assert merge_dicts_unique(a, b) == expected


@pytest.mark.parametrize("pos, expected_names", [
    (['a', 'b'], ['a', 'b']),
    (['param1', 'value_2', 'Z'], ['param1', 'value_2', 'Z']),
    ([], []),
])
def test_make_params_pos_basic(pos, expected_names):
    params = make_params_pos(pos)
    assert all(isinstance(p, inspect.Parameter) for p in params)
    assert [p.name for p in params] == expected_names
    assert all(p.default == inspect._empty for p in params)
    assert all(p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD for p in params)


@pytest.mark.parametrize("kw, expected_keys, expected_defaults", [
    ({'a': 1, 'b': 2}, ['a', 'b'], [1, 2]),
    ({'param_x': 0}, ['param_x'], [0]),
    ({}, [], []),
])
def test_make_params_kw_basic(kw, expected_keys, expected_defaults):
    params = make_params_kw(kw)
    assert all(isinstance(p, inspect.Parameter) for p in params)
    assert [p.name for p in params] == expected_keys
    assert [p.default for p in params] == expected_defaults
    assert all(p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD for p in params)

@pytest.mark.parametrize("pos, kw, expected_signature", [
    (['x', 'y'], {'z': 3}, '(x, y, z=3)'),
    (['a'], {'b': 1, 'c': 2}, '(a, b=1, c=2)'),
    ([], {'flag': False}, '(flag=False)'),
])
def test_make_signature_parametrized(pos, kw, expected_signature):
    sig = make_signature(pos, kw)
    assert isinstance(sig, inspect.Signature)
    assert str(sig) == expected_signature


@pytest.mark.parametrize("func, expected_pos, expected_kw", [
    (lambda a, b, c=3, *, d=4: None, ['a', 'b'], {'c': 3, 'd': 4}),
    (lambda x=1, *, y, z=0: None, [], {'x': 1, 'y': inspect._empty, 'z': 0}),
    (lambda *args, **kwargs: None, [], {}),
])
def test_get_args_parametrized(func, expected_pos, expected_kw):
    pos, kw = get_args(func)
    assert pos == expected_pos
    for k, v in expected_kw.items():
        if v is inspect._empty:
            assert k in kw and kw[k] == inspect._empty
        else:
            assert kw.get(k) == v



# Test : forwards_to

def func_target(a, b, c=10, d=20):  
    return a + b + c + d

@forwards_to(func_target, nfilled=0)
def wrap_all(a, b, *args, d=30, **kwargs):
    return func_target(a, b, *args, d=d, **kwargs)

@forwards_to(func_target, nfilled=2)
def wrap_skip(a, b, *args, **kwargs):
    return func_target(1, 2, *args, **kwargs)

@forwards_to(func_target, nfilled=4)  
def wrap_ignore_all(x, y):
    return func_target(1, 2, 3, 4)  

@pytest.mark.parametrize("func, expected_sig", [
    (wrap_all, '(a, b, d=30, c=10)'),
    (wrap_skip, '(a, b, c=10, d=20)'),
    (wrap_ignore_all, '(x, y, c=10, d=20)'),
])
def test_signature_visible(func, expected_sig):
    assert str(inspect.signature(func)) == expected_sig

@pytest.mark.parametrize("func, args, kwargs, expected_result", [
    (wrap_all, (1, 2, 3), {}, 1+2+3+30),
    (wrap_all, (1, 2, 3), {'d': 5}, 1+2+3+5),
    (wrap_skip, (0, 0), {'c': 3, 'd': 4}, 1+2+3+4),
    (wrap_ignore_all, (0, 0), {}, 1+2+3+4),
])
def test_wrapper_behavior(func, args, kwargs, expected_result):
    assert func(*args, **kwargs) == expected_result