"""Unit tests for DataServicesManager."""
import pandas as pd


class TestDataServicesManagerServiceLifecycle:
  def test_i_can_create_a_service(self, dsm):
    """create_service() returns a DataService accessible by grid_id."""
    service = dsm.create_service("ns.tbl", save_state=False)
    
    assert service is not None
    assert service.get_id() is not None
    assert dsm.get_service(service.get_id()) is service
  
  def test_i_can_create_service_with_correct_table_name(self, dsm):
    """create_service() sets the table_name on the returned DataService.
  
    create_service() calls service.set_table_name() internally.
    This test verifies the side effect is applied before returning the service.
    """
    service = dsm.create_service("ns.my_table", save_state=False)
    
    assert service.table_name == "ns.my_table"
  
  def test_i_can_create_service_forcing_the_id(self, dsm):
    """create_service() sets the table_name on the returned DataService.
  
    create_service() calls service.set_table_name() internally.
    This test verifies the side effect is applied before returning the service.
    """
    service = dsm.create_service("ns.my_table", _id="grid_id", save_state=False)
    
    assert service.get_id() == "grid_id"
  
  def test_i_can_get_a_service_by_grid_id(self, dsm):
    """get_service() returns the correct service."""
    svc1 = dsm.create_service("ns.t1", _id="g1", save_state=False)
    svc2 = dsm.create_service("ns.t2", _id="g2", save_state=False)
    
    assert dsm.get_service("g1") is svc1
    assert dsm.get_service("g2") is svc2
  
  def test_i_cannot_get_a_nonexistent_service(self, dsm):
    """get_service() returns None for unknown grid_id."""
    assert dsm.get_service("does_not_exist") is None
  
  def test_i_can_remove_a_service(self, dsm):
    """remove_service() unregisters the service."""
    service = dsm.create_service("ns.rm", save_state=False)
    dsm.remove_service(service.get_id())
    
    assert dsm.get_service(service.get_id()) is None
  
  def test_i_can_remove_a_nonexistent_service_without_error(self, dsm):
    """remove_service() on unknown grid_id does not raise."""
    dsm.remove_service("ghost")  # should not raise
  
  def test_i_can_restore_a_service(self, dsm):
    """restore_service() creates and registers a service if not already present."""
    service = dsm.restore_service("grid_restore")
    
    assert service is not None
    assert dsm.get_service("grid_restore") is service
    assert service.get_id() == "grid_restore"
  
  def test_i_can_restore_existing_service(self, dsm):
    """restore_service() returns the existing service when already registered."""
    original = dsm.create_service("ns.e", _id="grid_exist", save_state=False)
    restored = dsm.restore_service("grid_exist")
    
    assert restored is original


class TestDataServicesManagerFormulaEngine:
  
  def test_i_can_get_formula_engine(self, dsm):
    """get_formula_engine() returns the shared FormulaEngine instance."""
    engine = dsm.get_formula_engine()
    assert engine is not None
  
  def test_i_can_verify_shared_formula_engine(self, dsm):
    """All services share the same FormulaEngine from DataServicesManager."""
    svc1 = dsm.create_service("ns.fe1", save_state=False)
    svc2 = dsm.create_service("ns.fe2", save_state=False)
    
    assert svc1.get_formula_engine() is svc2.get_formula_engine()
    assert svc1.get_formula_engine() is dsm.get_formula_engine()
  
  def test_i_can_resolve_store_by_table_name(self, dsm):
    """FormulaEngine resolver finds the DataStore for a given table name."""
    service = dsm.create_service("ns.resolver", save_state=False)
    df = pd.DataFrame({"a": [1, 2]})
    service.load_dataframe(df)
    
    store = dsm._resolve_store_for_table("ns.resolver")
    
    assert store is service.get_store()
  
  def test_i_can_resolve_correct_store_among_multiple_services(self, dsm):
    """_resolve_store_for_table() identifies the right store when multiple services are registered.
  
    The resolver iterates over all registered services and must return the store
    whose service has a matching table_name, not another service's store.
    """
    svc_a = dsm.create_service("ns.table_a", save_state=False)
    svc_b = dsm.create_service("ns.table_b", save_state=False)
    
    df = pd.DataFrame({"x": [10, 20]})
    svc_a.load_dataframe(df)
    svc_b.load_dataframe(df.copy())
    
    store_a = dsm._resolve_store_for_table("ns.table_a")
    store_b = dsm._resolve_store_for_table("ns.table_b")
    
    assert store_a is svc_a.get_store()
    assert store_b is svc_b.get_store()
    assert store_a is not store_b
  
  def test_i_cannot_resolve_unknown_table(self, dsm):
    """FormulaEngine resolver returns None for an unknown table name."""
    result = dsm._resolve_store_for_table("unknown.table")
    assert result is None