import pickle
import pytest
import os
from unittest.mock import Mock
from recommendations.FloorRecommendations import FloorRecommendations
from recommendations.tests.test_data.materials import materials
from backend.Property import Property


# with open(
#     os.path.abspath(os.path.dirname(__file__)) + "/recommendations/tests/test_data/input_properties.pkl", "rb"
# ) as f:
#     input_properties = pickle.load(f)

class TestFloorRecommendations:

    @pytest.fixture
    def input_properties(self):
        with open(
            os.path.abspath(os.path.dirname(__file__)) + "/test_data/input_properties.pkl", "rb"
        ) as f:
            return pickle.load(f)

    def test_init(self, input_properties):
        input_properties[0].insulation_floor_area = 50
        input_properties[0].insulation_wall_area = 90
        obj = FloorRecommendations(
            property_instance=input_properties[0],
            materials=materials
        )
        assert obj
        assert obj.property

    def test_other_premises_below(self, input_properties):
        input_properties[0].insulation_floor_area = 100
        input_properties[0].insulation_wall_area = 999
        input_properties[0].number_of_floors = 1
        recommender = FloorRecommendations(
            property_instance=input_properties[0],
            materials=materials
        )
        recommender.recommend()
        assert recommender.property.floor["another_property_below"]

        assert not recommender.recommendations

    def test_suspended_no_insulation(self, input_properties):
        """
        For a suspended floor without insulation, we use the rdsap methogology to estimate a U-value for the floor
        :return:
        """

        input_properties[2].insulation_floor_area = 50
        input_properties[2].insulation_wall_area = 50
        input_properties[2].walls["is_park_home"] = False
        input_properties[2].age_band = "A"
        input_properties[2].perimeter = 20
        input_properties[2].wall_type = "solid brick"
        input_properties[2].floor_type = "suspended"
        input_properties[2].number_of_floors = 1
        input_properties[2].floor_level = 0

        recommender = FloorRecommendations(property_instance=input_properties[2], materials=materials)
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert recommender.property.floor["is_suspended"]
        assert recommender.estimated_u_value == 0.66
        assert recommender.recommendations

        types = {part["type"] for x in recommender.recommendations for part in x["parts"]}

        assert types == {"suspended_floor_insulation"}

        assert len(recommender.recommendations) == 6
        assert recommender.recommendations[0]["total"] == 4925.205
        assert recommender.recommendations[0]["new_u_value"] == 0.21

    def test_uvalue_0_12(self, input_properties):
        """
        This is a home that doesn't have a property below but it's highly performant already and therefore
        does not need floor insulation
        :return:
        """
        input_properties[3].insulation_floor_area = 100
        input_properties[3].insulation_wall_area = 100
        input_properties[3].number_of_floors = 1
        input_properties[3].floor_level = 0

        recommender = FloorRecommendations(property_instance=input_properties[3], materials=materials)
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert not recommender.property.floor["is_suspended"]
        assert not recommender.property.floor["is_solid"]
        assert recommender.estimated_u_value is None
        assert not recommender.recommendations

    def test_solid_no_insulation(self, input_properties):
        """
        :return:
        """

        input_properties[4].insulation_floor_area = 100
        input_properties[4].insulation_wall_area = 100
        input_properties[4].walls["is_park_home"] = False
        input_properties[4].age_band = "B"
        input_properties[4].perimeter = 50
        input_properties[4].wall_type = "solid brick"
        input_properties[4].floor_type = "solid"
        input_properties[4].number_of_floors = 1
        input_properties[4].floor_level = 0

        # In this case, we have no county, so in this case, it should yse the local-authority-label if possible
        input_properties[4].data["county"] = ""
        recommender = FloorRecommendations(property_instance=input_properties[4], materials=materials)
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert not recommender.property.floor["is_suspended"]
        assert recommender.property.floor["is_solid"]
        assert recommender.estimated_u_value == 0.73
        assert recommender.recommendations

        types = {part["type"] for x in recommender.recommendations for part in x["parts"]}

        assert types == {"solid_floor_insulation"}

        assert len(recommender.recommendations) == 3
        assert recommender.recommendations[2]["total"] == 14604.660000000002
        assert recommender.recommendations[2]["new_u_value"] == 0.21
        assert recommender.recommendations[2]["parts"][0]["depth"] == 75
        assert recommender.recommendations[2]["parts"][0]["depth"] == 75

    def test_another_dwelling_below(self, input_properties):
        """
        This is another description we see when there is a property below
        """

        input_properties[6].insulation_floor_area = 100
        input_properties[6].insulation_wall_area = 1

        input_properties[6].number_of_floors = 1
        recommender = FloorRecommendations(property_instance=input_properties[6], materials=materials)
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert not recommender.property.floor["is_suspended"]
        assert not recommender.property.floor["is_solid"]
        assert recommender.estimated_u_value is None
        assert not recommender.recommendations

    # def test_exposed_floor_no_insulation(self):
    #     input_property = Property(id=1, postcode="F4k3 2", address1="223 fake street", epc_client=Mock())
    #     input_property.floor = {
    #         'original_description': 'To unheated space, no insulation (assumed)',
    #         'clean_description': 'To unheated space, no insulation', 'thermal_transmittance': None,
    #         'thermal_transmittance_unit': None, 'is_assumed': True, 'is_to_unheated_space': True,
    #         'is_to_external_air': False, 'is_suspended': False, 'is_solid': False, 'another_property_below': False,
    #         'insulation_thickness': 'none'
    #     }
    #     input_property.age_band = "L"
    #     input_property.set_floor_type()
    #     input_property.data = {"floor-level": 0, "property-type": "House"}
    #     input_property.floor_area = 100
    #     input_property.number_of_floors = 1
    #
    #     recommender = FloorRecommendations(
    #         property_instance=input_property,
    #         materials=materials
    #     )
    #
    #     assert not recommender.recommendations
    #
    #     recommender.recommend()
    #
    #     # Because of age band L, this should have a u-value of 0.22 to begin with and no recommendation
    #     assert not len(recommender.recommendations)
    #     assert recommender.estimated_u_value == 0.22
    #
    #     # Now with an older age band
    #
    #     input_property2 = Property(id=1, postcode="F4k3 2", address1="223 fake street", epc_client=Mock())
    #     input_property2.floor = {
    #         'original_description': 'To unheated space, no insulation (assumed)',
    #         'clean_description': 'To unheated space, no insulation', 'thermal_transmittance': None,
    #         'thermal_transmittance_unit': None, 'is_assumed': True, 'is_to_unheated_space': True,
    #         'is_to_external_air': False, 'is_suspended': False, 'is_solid': False, 'another_property_below': False,
    #         'insulation_thickness': 'none'
    #     }
    #     input_property2.age_band = "D"
    #     input_property2.set_floor_type()
    #     input_property2.data = {"floor-level": 0, "property-type": "House"}
    #     input_property2.floor_area = 100
    #     input_property2.number_of_floors = 1
    #
    #     recommender2 = FloorRecommendations(
    #         property_instance=input_property2,
    #         materials=materials
    #     )
    #
    #     assert not recommender2.recommendations
    #
    #     recommender2.recommend()
    #
    #     assert len(recommender2.recommendations) == 1
    #
    #     assert recommender2.recommendations[0]["new_u_value"] == 0.23
    #     assert recommender2.recommendations[0]["starting_u_value"] == 1.2
    #     assert recommender2.recommendations[0]["cost"] == 1500
    #
    # def test_exposed_floor_below_average_insulated(self):
    #     input_property3 = Property(id=1, postcode="F4k3 2", address1="223 fake street", epc_client=Mock())
    #     input_property3.floor = {
    #         'original_description': 'To unheated space, below average insulation (assumed)',
    #         'clean_description': 'To unheated space, below average insulation', 'thermal_transmittance': None,
    #         'thermal_transmittance_unit': None, 'is_assumed': True, 'is_to_unheated_space': True,
    #         'is_to_external_air': False, 'is_suspended': False, 'is_solid': False, 'another_property_below': False,
    #         'insulation_thickness': 'below average'
    #     }
    #     input_property3.age_band = "C"
    #     input_property3.set_floor_type()
    #     input_property3.data = {"floor-level": 0, "property-type": "House"}
    #     input_property3.floor_area = 100
    #     input_property3.number_of_floors = 1
    #
    #     recommender3 = FloorRecommendations(
    #         property_instance=input_property3,
    #         materials=materials
    #     )
    #
    #     assert not recommender3.recommendations
    #
    #     recommender3.recommend()
    #
    #     assert recommender3.estimated_u_value == 0.5
    #
    #     assert len(recommender3.recommendations) == 1
    #
    #     assert recommender3.recommendations[0]["new_u_value"] == 0.22
    #     assert recommender3.recommendations[0]["starting_u_value"] == 0.5
    #     assert recommender3.recommendations[0]["cost"] == 1100
    #     assert recommender3.recommendations[0]["parts"][0]["depths"] == [100]
    #
    #     # With average insulation, no recommendations
    #
    #     input_property4 = Property(id=1, postcode="F4k3 2", address1="223 fake street", epc_client=Mock())
    #     input_property4.floor = {
    #         'original_description': 'To unheated space, insulated (assumed)',
    #         'clean_description': 'To unheated space, insulated', 'thermal_transmittance': None,
    #         'thermal_transmittance_unit': None, 'is_assumed': True, 'is_to_unheated_space': True,
    #         'is_to_external_air': False, 'is_suspended': False, 'is_solid': False, 'another_property_below': False,
    #         'insulation_thickness': 'average'
    #     }
    #     input_property4.age_band = "C"
    #     input_property4.set_floor_type()
    #     input_property4.data = {"floor-level": 0, "property-type": "House"}
    #     input_property4.floor_area = 100
    #     input_property4.number_of_floors = 1
    #
    #     recommender4 = FloorRecommendations(
    #         property_instance=input_property4,
    #         materials=materials
    #     )
    #
    #     assert not recommender4.recommendations
    #
    #     recommender4.recommend()
    #
    #     assert recommender4.estimated_u_value is None
    #
    #     assert len(recommender4.recommendations) == 0
