import dataclasses

import pytest

from core.settings_management import SettingsManager, MemoryDbEngine, GenericDbManager, NestedSettingsManager

FAKE_USER_ID = "FakeUserId"


@dataclasses.dataclass
class DummyObject:
  a: int
  b: str
  c: bool


@dataclasses.dataclass
class DummySettings:
  prop1: DummyObject
  prop2: str


@dataclasses.dataclass
class DummyObjectWithDefault:
  a: int = 5
  b: str = "default_b"
  c: bool = False


@dataclasses.dataclass
class DummySettingsWithDefault:
  prop1: DummyObjectWithDefault = dataclasses.field(default_factory=DummyObjectWithDefault)
  prop2: str = "prop2"


@pytest.fixture()
def manager():
  return SettingsManager(MemoryDbEngine())


@pytest.fixture()
def settings():
  return DummySettings(
    prop1=DummyObject(1, "2", True),
    prop2="prop2_new",
  )


@pytest.fixture()
def generic_db_manager(session, manager):
  return GenericDbManager(session, manager, "TestSettings", DummySettingsWithDefault)


@pytest.fixture()
def nested_settings_manager(session, manager):
  return NestedSettingsManager(session, manager, "TestSettings", DummySettingsWithDefault, "prop1")


def test_i_can_save_and_load_settings(session, manager, settings):
  manager.save(session, "MyEntry", settings)
  
  from_db = manager.load(session, "MyEntry")
  
  assert isinstance(from_db, DummySettings)
  assert from_db.prop1.a == 1
  assert from_db.prop1.b == "2"
  assert from_db.prop1.c == True
  assert from_db.prop2 == "prop2_new"


def test_i_can_have_two_entries(session, manager, settings):
  manager.save(session, "MyEntry", settings)
  manager.save(session, "MyOtherEntry", settings)
  
  from_db = manager.load(session, "MyEntry")
  from_db_other = manager.load(session, "MyOtherEntry")
  
  assert isinstance(from_db, DummySettings)
  assert isinstance(from_db_other, DummySettings)


def test_i_can_put_many_items_dict(session, manager):
  manager.save(session, "TestEntry", {})
  
  items = {
      'key1': 'value1',
      'key2': 'value2',
      'key3': 'value3'
  }
  manager.put_many(session, "TestEntry", items)
  
  loaded = manager.load(session, "TestEntry")
  assert loaded['key1'] == 'value1'
  assert loaded['key2'] == 'value2'
  assert loaded['key3'] == 'value3'


def test_i_can_put_many_items_list(session, manager):
  manager.save(session, "TestEntry", {})
  
  items = [
      ('key1', 'value1'),
      ('key2', 'value2'),
      ('key3', 'value3')
  ]
  manager.put_many(session, "TestEntry", items)
  
  loaded = manager.load(session, "TestEntry")
  assert loaded['key1'] == 'value1'
  assert loaded['key2'] == 'value2'
  assert loaded['key3'] == 'value3'


# Tests for GenericDbManager

def test_generic_db_manager_get_attribute(generic_db_manager, manager, session):
  # Setup initial settings
  initial_settings = DummySettingsWithDefault(
    prop1=DummyObjectWithDefault(1, "2", True),
    prop2="initial_value"
  )
  manager.save(session, "TestSettings", initial_settings)
  
  # Get attribute via GenericDbManager
  assert generic_db_manager.prop2 == "initial_value"
  assert generic_db_manager.prop1.a == 1
  assert generic_db_manager.prop1.b == "2"
  assert generic_db_manager.prop1.c is True


def test_generic_db_manager_set_attribute(generic_db_manager, manager, session):
  # Setup initial settings
  initial_settings = DummySettingsWithDefault(
    prop1=DummyObjectWithDefault(1, "2", True),
    prop2="initial_value"
  )
  manager.save(session, "TestSettings", initial_settings)
  
  # Set attribute via GenericDbManager
  generic_db_manager.prop2 = "updated_value"
  
  # Verify that the change was saved to the database
  loaded_settings = manager.load(session, "TestSettings")
  assert loaded_settings.prop2 == "updated_value"
  
  # Also verify direct access works
  assert generic_db_manager.prop2 == "updated_value"


def test_generic_db_manager_set_nested_attribute(generic_db_manager, manager, session):
  # Setup initial settings
  initial_settings = DummySettingsWithDefault(
    prop1=DummyObjectWithDefault(1, "2", True),
    prop2="initial_value"
  )
  manager.save(session, "TestSettings", initial_settings)
  
  # Set nested attribute
  generic_db_manager.prop1.a = 42
  generic_db_manager.prop1.b = "modified"
  generic_db_manager.prop1.c = False
  
  # Verify the changes were saved
  loaded_settings = manager.load(session, "TestSettings")
  assert loaded_settings.prop1.a == 42
  assert loaded_settings.prop1.b == "modified"
  assert loaded_settings.prop1.c is False


def test_generic_db_manager_attribute_error(generic_db_manager):
  # Test that accessing a non-existent attribute raises AttributeError
  with pytest.raises(AttributeError) as excinfo:
    generic_db_manager.non_existent_attribute
  
  assert "has no attribute 'non_existent_attribute'." in str(excinfo.value)


def test_generic_db_manager_set_attribute_error(generic_db_manager):
  # Test that setting a non-existent attribute raises AttributeError
  with pytest.raises(AttributeError) as excinfo:
    generic_db_manager.non_existent_attribute = "value"
  
  assert "has no attribute 'non_existent_attribute'." in str(excinfo.value)


def test_generic_db_manager_no_initialization(session, manager):
  # Test initialization with default object
  db_manager = GenericDbManager(session, manager, "TestSettings", DummySettingsWithDefault)
  
  value = db_manager.prop2  # Accessing an attribute will create a new entry
  assert value == "prop2"


def test_generic_db_manager_no_initialization_set(session, manager):
  db_manager = GenericDbManager(session, manager, "TestSettings", DummySettingsWithDefault)
  
  db_manager.prop2 = "new_value"
  
  # Verify that a default object was created and saved
  loaded_settings = manager.load(session, "TestSettings")
  assert isinstance(loaded_settings, DummySettingsWithDefault)
  
  # The attributes should have their default values
  assert loaded_settings.prop1.a == 5
  assert loaded_settings.prop1.b == "default_b"
  assert loaded_settings.prop1.c is False
  assert loaded_settings.prop2 == "new_value"


# Tests for NestedSettingsManager

def test_nested_settings_manager_get_attribute(nested_settings_manager, manager, session):
  # Setup initial settings
  initial_settings = DummySettingsWithDefault(
    prop1=DummyObjectWithDefault(10, "test_value", True),
    prop2="initial_value"
  )
  manager.save(session, "TestSettings", initial_settings)
  
  # Get attributes via NestedSettingsManager
  assert nested_settings_manager.a == 10
  assert nested_settings_manager.b == "test_value"
  assert nested_settings_manager.c is True


def test_nested_settings_manager_set_attribute(nested_settings_manager, manager, session):
  # Setup initial settings
  initial_settings = DummySettingsWithDefault(
    prop1=DummyObjectWithDefault(10, "test_value", True),
    prop2="initial_value"
  )
  manager.save(session, "TestSettings", initial_settings)
  
  # Set attribute via NestedSettingsManager
  nested_settings_manager.a = 99
  nested_settings_manager.b = "updated_nested_value"
  nested_settings_manager.c = False
  
  # Verify that the changes were saved to the database
  loaded_settings = manager.load(session, "TestSettings")
  assert loaded_settings.prop1.a == 99
  assert loaded_settings.prop1.b == "updated_nested_value"
  assert loaded_settings.prop1.c is False
  
  # Also verify direct access works
  assert nested_settings_manager.a == 99
  assert nested_settings_manager.b == "updated_nested_value"
  assert nested_settings_manager.c is False


def test_nested_settings_manager_attribute_error(nested_settings_manager):
  # Test that accessing a non-existent attribute raises AttributeError
  with pytest.raises(AttributeError) as excinfo:
    nested_settings_manager.non_existent_attribute
  
  assert "has no attribute 'non_existent_attribute'" in str(excinfo.value)


def test_nested_settings_manager_set_attribute_error(nested_settings_manager):
  # Test that setting a non-existent attribute raises AttributeError
  with pytest.raises(AttributeError) as excinfo:
    nested_settings_manager.non_existent_attribute = "value"
  
  assert "has no attribute 'non_existent_attribute'" in str(excinfo.value)


def test_nested_settings_manager_no_initialization(session, manager):
  # Test initialization with default object
  nested_db_manager = NestedSettingsManager(session, manager, "TestSettings", DummySettingsWithDefault, "prop1")
  
  # Accessing an attribute will create a new entry with default values
  assert nested_db_manager.a == 5
  assert nested_db_manager.b == "default_b"
  assert nested_db_manager.c is False


def test_nested_settings_manager_no_initialization_set(session, manager):
  nested_db_manager = NestedSettingsManager(session, manager, "TestSettings", DummySettingsWithDefault, "prop1")
  
  # Set attribute will create a new entry with the modified value
  nested_db_manager.a = 42
  
  # Verify that a default object was created and saved
  loaded_settings = manager.load(session, "TestSettings")
  assert isinstance(loaded_settings, DummySettingsWithDefault)
  
  # The specified attribute should be updated, while others retain default values
  assert loaded_settings.prop1.a == 42
  assert loaded_settings.prop1.b == "default_b"
  assert loaded_settings.prop1.c is False
  assert loaded_settings.prop2 == "prop2"


def test_nested_settings_manager_invalid_nested_attribute(session, manager):
  # Test with an invalid nested attribute
  invalid_nested_manager = NestedSettingsManager(session, manager, "TestSettings", DummySettingsWithDefault,
                                                 "non_existent")
  
  # Accessing any attribute should raise an AttributeError
  with pytest.raises(AttributeError) as excinfo:
    invalid_nested_manager.a
  
  assert "has no attribute 'non_existent'" in str(excinfo.value)


def test_i_can_update_nested_settings(nested_settings_manager, session, manager):
  new_values = {
      "a": 10,
      "b": "new_value",
      "c": True,
  }
  nested_settings_manager.update(new_values)
  
  # Verify that a default object was created and saved
  loaded_settings = manager.load(session, "TestSettings")
  assert isinstance(loaded_settings, DummySettingsWithDefault)
  
  # The specified attribute should be updated, while others retain default values
  assert loaded_settings.prop1.a == 10
  assert loaded_settings.prop1.b == "new_value"
  assert loaded_settings.prop1.c is True