"""The test for the bayesian sensor platform."""
import unittest

from homeassistant.setup import setup_component
from homeassistant.components.bayesian import binary_sensor as bayesian

from tests.common import get_test_home_assistant


class TestBayesianBinarySensor(unittest.TestCase):
    """Test the threshold sensor."""

    def setup_method(self, method):
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()

    def teardown_method(self, method):
        """Stop everything that was started."""
        self.hass.stop()

    def test_sensor_numeric_state(self):
        """Test sensor on numeric state platform observations."""
        config = {
            "binary_sensor": {
                "platform": "bayesian",
                "name": "Test_Binary",
                "observations": [
                    {
                        "platform": "numeric_state",
                        "entity_id": "sensor.test_monitored",
                        "below": 10,
                        "above": 5,
                        "prob_given_true": 0.6,
                    },
                    {
                        "platform": "numeric_state",
                        "entity_id": "sensor.test_monitored1",
                        "below": 7,
                        "above": 5,
                        "prob_given_true": 0.9,
                        "prob_given_false": 0.1,
                    },
                ],
                "prior": 0.2,
            }
        }

        assert setup_component(self.hass, "binary_sensor", config)

        self.hass.states.set("sensor.test_monitored", 4)
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")

        assert [] == state.attributes.get("observations")
        assert 0.2 == state.attributes.get("probability")

        assert state.state == "off"

        self.hass.states.set("sensor.test_monitored", 6)
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", 4)
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", 6)
        self.hass.states.set("sensor.test_monitored1", 6)
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")
        assert [
            {"prob_false": 0.4, "prob_true": 0.6},
            {"prob_false": 0.1, "prob_true": 0.9},
        ] == state.attributes.get("observations")
        assert round(abs(0.77 - state.attributes.get("probability")), 7) == 0

        assert state.state == "on"

        self.hass.states.set("sensor.test_monitored", 6)
        self.hass.states.set("sensor.test_monitored1", 0)
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", 4)
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")
        assert 0.2 == state.attributes.get("probability")

        assert state.state == "off"

        self.hass.states.set("sensor.test_monitored", 15)
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")

        assert state.state == "off"

    def test_sensor_state(self):
        """Test sensor on state platform observations."""
        config = {
            "binary_sensor": {
                "name": "Test_Binary",
                "platform": "bayesian",
                "observations": [
                    {
                        "platform": "state",
                        "entity_id": "sensor.test_monitored",
                        "to_state": "off",
                        "prob_given_true": 0.8,
                        "prob_given_false": 0.4,
                    }
                ],
                "prior": 0.2,
                "probability_threshold": 0.32,
            }
        }

        assert setup_component(self.hass, "binary_sensor", config)

        self.hass.states.set("sensor.test_monitored", "on")

        state = self.hass.states.get("binary_sensor.test_binary")

        assert [] == state.attributes.get("observations")
        assert 0.2 == state.attributes.get("probability")

        assert state.state == "off"

        self.hass.states.set("sensor.test_monitored", "off")
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", "on")
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", "off")
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")
        assert [{"prob_true": 0.8, "prob_false": 0.4}] == state.attributes.get(
            "observations"
        )
        assert round(abs(0.33 - state.attributes.get("probability")), 7) == 0

        assert state.state == "on"

        self.hass.states.set("sensor.test_monitored", "off")
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", "on")
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")
        assert round(abs(0.2 - state.attributes.get("probability")), 7) == 0

        assert state.state == "off"

    def test_threshold(self):
        """Test sensor on probabilty threshold limits."""
        config = {
            "binary_sensor": {
                "name": "Test_Binary",
                "platform": "bayesian",
                "observations": [
                    {
                        "platform": "state",
                        "entity_id": "sensor.test_monitored",
                        "to_state": "on",
                        "prob_given_true": 1.0,
                    }
                ],
                "prior": 0.5,
                "probability_threshold": 1.0,
            }
        }

        assert setup_component(self.hass, "binary_sensor", config)

        self.hass.states.set("sensor.test_monitored", "on")
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")
        assert round(abs(1.0 - state.attributes.get("probability")), 7) == 0

        assert state.state == "on"

    def test_multiple_observations(self):
        """Test sensor with multiple observations of same entity."""
        config = {
            "binary_sensor": {
                "name": "Test_Binary",
                "platform": "bayesian",
                "observations": [
                    {
                        "platform": "state",
                        "entity_id": "sensor.test_monitored",
                        "to_state": "blue",
                        "prob_given_true": 0.8,
                        "prob_given_false": 0.4,
                    },
                    {
                        "platform": "state",
                        "entity_id": "sensor.test_monitored",
                        "to_state": "red",
                        "prob_given_true": 0.2,
                        "prob_given_false": 0.4,
                    },
                ],
                "prior": 0.2,
                "probability_threshold": 0.32,
            }
        }

        assert setup_component(self.hass, "binary_sensor", config)

        self.hass.states.set("sensor.test_monitored", "off")

        state = self.hass.states.get("binary_sensor.test_binary")

        assert [] == state.attributes.get("observations")
        assert 0.2 == state.attributes.get("probability")

        assert state.state == "off"

        self.hass.states.set("sensor.test_monitored", "blue")
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", "off")
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", "blue")
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")
        assert [{"prob_true": 0.8, "prob_false": 0.4}] == state.attributes.get(
            "observations"
        )
        assert round(abs(0.33 - state.attributes.get("probability")), 7) == 0

        assert state.state == "on"

        self.hass.states.set("sensor.test_monitored", "blue")
        self.hass.block_till_done()
        self.hass.states.set("sensor.test_monitored", "red")
        self.hass.block_till_done()

        state = self.hass.states.get("binary_sensor.test_binary")
        assert round(abs(0.11 - state.attributes.get("probability")), 7) == 0

        assert state.state == "off"

    def test_probability_updates(self):
        """Test probability update function."""
        prob_true = [0.3, 0.6, 0.8]
        prob_false = [0.7, 0.4, 0.2]
        prior = 0.5

        for pt, pf in zip(prob_true, prob_false):
            prior = bayesian.update_probability(prior, pt, pf)

        assert round(abs(0.720000 - prior), 7) == 0

        prob_true = [0.8, 0.3, 0.9]
        prob_false = [0.6, 0.4, 0.2]
        prior = 0.7

        for pt, pf in zip(prob_true, prob_false):
            prior = bayesian.update_probability(prior, pt, pf)

        assert round(abs(0.9130434782608695 - prior), 7) == 0