import os.path
import shutil

import pandas as pd
import pytest

from core.dbengine import DbEngine, TAG_PARENT
from core.settings_objects import BudgetTrackerSettings, BudgetTrackerFile, BudgetTrackerFiles
DB_ENGINE_ROOT = "TestDBEngineRoot"
FAKE_USER_ID = "FakeUserId"


@pytest.fixture()
def engine():
    if os.path.exists(DB_ENGINE_ROOT):
        shutil.rmtree(DB_ENGINE_ROOT)

    engine = DbEngine(DB_ENGINE_ROOT)
    engine.init()
    return engine


@pytest.fixture()
def dummy_obj():
    return BudgetTrackerSettings(
        spread_sheet="spread_sheet",
        col_row_num="row_number",
        col_project="project",
        col_owner="owner",
        col_capex="capex",
        col_details="details",
        col_supplier="supplier",
        col_budget_amt="budget",
        col_actual_amt="actual",
        col_forecast5_7_amt="forecast5_7",
    )


@pytest.fixture()
def dummy_obj2():
    return BudgetTrackerSettings(
        spread_sheet="spread_sheet2",
        col_row_num="row_number2",
        col_project="project2",
        col_owner="owner2",
        col_capex="capex2",
        col_details="details2",
        col_supplier="supplier2",
        col_budget_amt="budget2",
        col_actual_amt="actual2",
        col_forecast5_7_amt="forecast5_72",
    )


def test_i_can_test_init():
    if os.path.exists(DB_ENGINE_ROOT):
        shutil.rmtree(DB_ENGINE_ROOT)

    engine = DbEngine(DB_ENGINE_ROOT)
    assert not engine.is_initialized()

    engine.init()
    assert engine.is_initialized()


def test_i_can_save_and_load(engine, dummy_obj):
    engine.save(FAKE_USER_ID, "MyEntry", dummy_obj)

    res = engine.load(FAKE_USER_ID, "MyEntry")
    assert isinstance(res, BudgetTrackerSettings)

    assert res.spread_sheet == dummy_obj.spread_sheet
    assert res.col_row_num == dummy_obj.col_row_num
    assert res.col_project == dummy_obj.col_project
    assert res.col_owner == dummy_obj.col_owner
    assert res.col_capex == dummy_obj.col_capex
    assert res.col_details == dummy_obj.col_details
    assert res.col_supplier == dummy_obj.col_supplier
    assert res.col_budget_amt == dummy_obj.col_budget_amt
    assert res.col_actual_amt == dummy_obj.col_actual_amt
    assert res.col_forecast5_7_amt == dummy_obj.col_forecast5_7_amt


def test_i_can_save_using_ref(engine):
    data = {
        'Key1': ['A', 'B', 'C'],
        'Key2': ['X', 'Y', 'Z'],
        'Percentage': [0.1, 0.2, 0.15],
    }
    df = pd.DataFrame(data)

    obj = BudgetTrackerFile(2024, 8, data=df)

    engine.save(FAKE_USER_ID, "MyEntry", obj)

    res = engine.load(FAKE_USER_ID, "MyEntry")
    assert isinstance(res, BudgetTrackerFile)

    assert res.year == obj.year
    assert res.month == obj.month
    assert res.data.to_dict() == obj.data.to_dict()


def test_i_can_use_ref_when_subclass(engine):
    data1 = {'Key': ['A'], 'Value': [0.1]}
    data2 = {'Key': ['B'], 'Value': [0.2]}
    file1 = BudgetTrackerFile(2024, 8, data=pd.DataFrame(data1))
    file2 = BudgetTrackerFile(2024, 9, data=pd.DataFrame(data2))
    files = BudgetTrackerFiles([file1, file2])

    engine.save(FAKE_USER_ID, "MyEntry", files)

    res = engine.load(FAKE_USER_ID, "MyEntry")
    assert isinstance(res, BudgetTrackerFiles)
    assert len(res.files) == 2


def test_i_can_put_and_get_one_object(engine, dummy_obj):
    engine.put(FAKE_USER_ID, "MyEntry", "key1", dummy_obj)
    from_db = engine.get(FAKE_USER_ID, "MyEntry", "key1")

    assert from_db == dummy_obj


def test_i_can_put_and_get_multiple_objects(engine, dummy_obj, dummy_obj2):
    engine.put(FAKE_USER_ID, "MyEntry", "key1", dummy_obj)
    engine.put(FAKE_USER_ID, "MyEntry", "key2", dummy_obj2)

    from_db1 = engine.get(FAKE_USER_ID, "MyEntry", "key1")
    from_db2 = engine.get(FAKE_USER_ID, "MyEntry", "key2")

    assert from_db1 == dummy_obj
    assert from_db2 == dummy_obj2

    all_items = engine.get(FAKE_USER_ID, "MyEntry")
    assert all_items == [dummy_obj, dummy_obj2]


def test_i_automatically_replace_keys(engine, dummy_obj, dummy_obj2):
    engine.put(FAKE_USER_ID, "MyEntry", "key1", dummy_obj)
    engine.put(FAKE_USER_ID, "MyEntry", "key1", dummy_obj2)

    from_db1 = engine.get(FAKE_USER_ID, "MyEntry", "key1")
    assert from_db1 == dummy_obj2

    all_items = engine.get(FAKE_USER_ID, "MyEntry")
    assert all_items == [dummy_obj2]


def test_i_do_not_save_twice_when_the_entries_are_the_same(engine, dummy_obj):
    engine.put(FAKE_USER_ID, "MyEntry", "key1", dummy_obj)

    entry_content = engine.load(FAKE_USER_ID, "MyEntry")
    assert entry_content[TAG_PARENT] == [None]

    # Save the same entry again
    engine.put(FAKE_USER_ID, "MyEntry", "key1", dummy_obj)

    entry_content = engine.load(FAKE_USER_ID, "MyEntry")
    assert entry_content[TAG_PARENT] == [None]  # still no other parent


def test_i_can_put_many(engine, dummy_obj, dummy_obj2):
    engine.put_many(FAKE_USER_ID, "MyEntry", [dummy_obj, dummy_obj2])

    from_db1 = engine.get(FAKE_USER_ID, "MyEntry", "spread_sheet")
    from_db2 = engine.get(FAKE_USER_ID, "MyEntry", "spread_sheet2")

    assert from_db1 == dummy_obj
    assert from_db2 == dummy_obj2

    entry_content = engine.load(FAKE_USER_ID, "MyEntry")
    assert entry_content[TAG_PARENT] == [None]  # only one save was made


def test_i_can_do_not_save_in_not_necessary(engine, dummy_obj, dummy_obj2):
    engine.put_many(FAKE_USER_ID, "MyEntry", [dummy_obj, dummy_obj2])
    engine.put_many(FAKE_USER_ID, "MyEntry", [dummy_obj, dummy_obj2])

    entry_content = engine.load(FAKE_USER_ID, "MyEntry")
    assert entry_content[TAG_PARENT] == [None]  # Still None, nothing was saved