# from utils import column_to_number
#
#
# def test_can_column_to_number():
#     assert column_to_number("A") == 1
#     assert column_to_number("AA") == 27
#     assert column_to_number("ZZZ") == 475254
import ast

import pytest
from fasthtml.components import Div

from core.utils import make_html_id, update_elements, snake_case_to_capitalized_words, merge_classes, \
  UnreferencedNamesVisitor


@pytest.mark.parametrize("string, expected", [
    ("My Example String!", "My-Example-String_"),
    ("123 Bad ID", "id_123-Bad-ID"),
    (None, None)
])
def test_i_can_have_valid_html_id(string, expected):
  assert make_html_id(string) == expected


def test_i_can_update_elements_when_null():
  assert update_elements(None, []) is None


def test_i_can_update_elements_when_wrong_id():
  div = Div(id="wrong", value="original value")
  updates = [{"id": "correct_id", "value": "new value", "method": "value"}]
  
  res = update_elements(div, updates)
  assert res.id == "wrong"
  assert res.value == "original value"


def test_i_can_update_elements_when_correct_id():
  div = Div(id="correct_id", value="original value")
  updates = [{"id": "correct_id", "value": "new value", "method": "value"}]
  
  res = update_elements(div, updates)
  assert res.id == "correct_id"
  assert res.value == "new value"


def test_i_can_update_elements_when_list_of_elements():
  div1 = Div(id="correct_id", value="original value")
  div2 = Div(id="correct_id", value="original value")
  updates = [{"id": "correct_id", "value": "new value", "method": "value"}]
  
  res = update_elements([div1, div2], updates)
  assert res[0].id == "correct_id"
  assert res[0].value == "new value"
  assert res[1].id == "correct_id"
  assert res[1].value == "new value"


def test_i_can_update_elements_list_of_elements_with_different_updates():
  div1 = Div(id="id1", value="original value")
  div2 = Div(id="id2", value="original value")
  updates = [{"id": "id1", "value": "value1", "method": "value"},
             {"id": "id2", "value": "value2", "method": "value"}, ]
  
  res = update_elements([div1, div2], updates)
  assert res[0].id == "id1"
  assert res[0].value == "value1"
  assert res[1].id == "id2"
  assert res[1].value == "value2"


def test_i_can_update_elements_when_children():
  child1 = Div(id="id2", value="original value")
  child2 = Div(id="wrong id", value="original value")
  child3 = Div(id="id3", value="original value")
  div1 = Div(child1, child2, child3, id="id1", value="original value")
  
  updates = [{"id": "id1", "value": "value1", "method": "value"},
             {"id": "id2", "value": "value2", "method": "value"},
             {"id": "id3", "value": "value3", "method": "value"}, ]
  
  res = update_elements(div1, updates)
  assert res.id == "id1"
  assert res.value == "value1"
  assert res.children[0].id == "id2"
  assert res.children[0].value == "value2"
  assert res.children[1].id == "wrong id"
  assert res.children[1].value == "original value"
  assert res.children[2].id == "id3"
  assert res.children[2].value == "value3"


@pytest.mark.parametrize("snake_case, expected", [
    ("column", "Column"),
    ("column_name", "Column Name"),
    ("this_is_a_column_name", "This Is A Column Name"),
    ("Column_Name", "Column Name"),
    ("column__name", "Column  Name"),
    ("This Is A Column Name", "This is a column name"),
])
def test_can_snake_case_to_capitalized_words(snake_case, expected):
  assert snake_case_to_capitalized_words(snake_case) == expected


def test_i_can_merge_cls():
  # basic use cases
  assert merge_classes() is None
  assert merge_classes("class1") == "class1"
  assert merge_classes("class1", "class2") == "class1 class2"
  
  # using dict
  kwargs = {}
  assert merge_classes("class1", kwargs) == "class1"
  assert kwargs == {}
  
  kwargs = {"foo": "bar"}
  assert merge_classes("class1", kwargs) == "class1"
  assert kwargs == {"foo": "bar"}
  
  kwargs = {"foo": "bar", "cls": "class2"}
  assert merge_classes("class1", kwargs) == "class1 class2"
  assert kwargs == {"foo": "bar"}
  
  kwargs = {"foo": "bar", "class": "class2"}
  assert merge_classes("class1", kwargs) == "class1 class2"
  assert kwargs == {"foo": "bar"}
  
  # using tuples
  assert merge_classes("class1", ("class2", "class3")) == "class1 class2 class3"
  
  # values are unique
  assert merge_classes("class2", "class1", ("class1",), {"cls": "class1"}) == "class2 class1"


@pytest.mark.parametrize("source, expected", [
    ("a,b", {"a", "b"}),
    ("isinstance(a, int)", {"a", "int"}),
    ("date.today()", set()),
    ("test()", set()),
    ("sheerka.test()", set()),
    ("for i in range(10): pass", set()),
    ("func(x=a, y=b)", {"a", "b", "x", "y"}),
])
def test_i_can_get_unreferenced_variables_from_simple_expressions(source, expected):
  ast_ = ast.parse(source)
  visitor = UnreferencedNamesVisitor()
  visitor.visit(ast_)
  
  assert visitor.names == expected