"""The tests for the Light component."""
# pylint: disable=protected-access
import unittest
import unittest.mock as mock
import os
from io import StringIO

import pytest

from homeassistant import core
from homeassistant.exceptions import Unauthorized
from homeassistant.setup import setup_component, async_setup_component
from homeassistant.const import (
    ATTR_ENTITY_ID,
    STATE_ON,
    STATE_OFF,
    CONF_PLATFORM,
    SERVICE_TURN_ON,
    SERVICE_TURN_OFF,
    SERVICE_TOGGLE,
    ATTR_SUPPORTED_FEATURES,
)
from homeassistant.components import light
from homeassistant.helpers.intent import IntentHandleError

from tests.common import (
    async_mock_service,
    mock_service,
    get_test_home_assistant,
    mock_storage,
)
from tests.components.light import common


class TestLight(unittest.TestCase):
    """Test the light module."""

    # pylint: disable=invalid-name
    def setUp(self):
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()

    # pylint: disable=invalid-name
    def tearDown(self):
        """Stop everything that was started."""
        self.hass.stop()

        user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)

        if os.path.isfile(user_light_file):
            os.remove(user_light_file)

    def test_methods(self):
        """Test if methods call the services as expected."""
        # Test is_on
        self.hass.states.set("light.test", STATE_ON)
        assert light.is_on(self.hass, "light.test")

        self.hass.states.set("light.test", STATE_OFF)
        assert not light.is_on(self.hass, "light.test")

        self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_ON)
        assert light.is_on(self.hass)

        self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_OFF)
        assert not light.is_on(self.hass)

        # Test turn_on
        turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON)

        common.turn_on(
            self.hass,
            entity_id="entity_id_val",
            transition="transition_val",
            brightness="brightness_val",
            rgb_color="rgb_color_val",
            xy_color="xy_color_val",
            profile="profile_val",
            color_name="color_name_val",
            white_value="white_val",
        )

        self.hass.block_till_done()

        assert 1 == len(turn_on_calls)
        call = turn_on_calls[-1]

        assert light.DOMAIN == call.domain
        assert SERVICE_TURN_ON == call.service
        assert "entity_id_val" == call.data.get(ATTR_ENTITY_ID)
        assert "transition_val" == call.data.get(light.ATTR_TRANSITION)
        assert "brightness_val" == call.data.get(light.ATTR_BRIGHTNESS)
        assert "rgb_color_val" == call.data.get(light.ATTR_RGB_COLOR)
        assert "xy_color_val" == call.data.get(light.ATTR_XY_COLOR)
        assert "profile_val" == call.data.get(light.ATTR_PROFILE)
        assert "color_name_val" == call.data.get(light.ATTR_COLOR_NAME)
        assert "white_val" == call.data.get(light.ATTR_WHITE_VALUE)

        # Test turn_off
        turn_off_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_OFF)

        common.turn_off(
            self.hass, entity_id="entity_id_val", transition="transition_val"
        )

        self.hass.block_till_done()

        assert 1 == len(turn_off_calls)
        call = turn_off_calls[-1]

        assert light.DOMAIN == call.domain
        assert SERVICE_TURN_OFF == call.service
        assert "entity_id_val" == call.data[ATTR_ENTITY_ID]
        assert "transition_val" == call.data[light.ATTR_TRANSITION]

        # Test toggle
        toggle_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TOGGLE)

        common.toggle(self.hass, entity_id="entity_id_val", transition="transition_val")

        self.hass.block_till_done()

        assert 1 == len(toggle_calls)
        call = toggle_calls[-1]

        assert light.DOMAIN == call.domain
        assert SERVICE_TOGGLE == call.service
        assert "entity_id_val" == call.data[ATTR_ENTITY_ID]
        assert "transition_val" == call.data[light.ATTR_TRANSITION]

    def test_services(self):
        """Test the provided services."""
        platform = getattr(self.hass.components, "test.light")

        platform.init()
        assert setup_component(
            self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
        )

        ent1, ent2, ent3 = platform.ENTITIES

        # Test init
        assert light.is_on(self.hass, ent1.entity_id)
        assert not light.is_on(self.hass, ent2.entity_id)
        assert not light.is_on(self.hass, ent3.entity_id)

        # Test basic turn_on, turn_off, toggle services
        common.turn_off(self.hass, entity_id=ent1.entity_id)
        common.turn_on(self.hass, entity_id=ent2.entity_id)

        self.hass.block_till_done()

        assert not light.is_on(self.hass, ent1.entity_id)
        assert light.is_on(self.hass, ent2.entity_id)

        # turn on all lights
        common.turn_on(self.hass)

        self.hass.block_till_done()

        assert light.is_on(self.hass, ent1.entity_id)
        assert light.is_on(self.hass, ent2.entity_id)
        assert light.is_on(self.hass, ent3.entity_id)

        # turn off all lights
        common.turn_off(self.hass)

        self.hass.block_till_done()

        assert not light.is_on(self.hass, ent1.entity_id)
        assert not light.is_on(self.hass, ent2.entity_id)
        assert not light.is_on(self.hass, ent3.entity_id)

        # turn off all lights by setting brightness to 0
        common.turn_on(self.hass)

        self.hass.block_till_done()

        common.turn_on(self.hass, brightness=0)

        self.hass.block_till_done()

        assert not light.is_on(self.hass, ent1.entity_id)
        assert not light.is_on(self.hass, ent2.entity_id)
        assert not light.is_on(self.hass, ent3.entity_id)

        # toggle all lights
        common.toggle(self.hass)

        self.hass.block_till_done()

        assert light.is_on(self.hass, ent1.entity_id)
        assert light.is_on(self.hass, ent2.entity_id)
        assert light.is_on(self.hass, ent3.entity_id)

        # toggle all lights
        common.toggle(self.hass)

        self.hass.block_till_done()

        assert not light.is_on(self.hass, ent1.entity_id)
        assert not light.is_on(self.hass, ent2.entity_id)
        assert not light.is_on(self.hass, ent3.entity_id)

        # Ensure all attributes process correctly
        common.turn_on(
            self.hass, ent1.entity_id, transition=10, brightness=20, color_name="blue"
        )
        common.turn_on(
            self.hass, ent2.entity_id, rgb_color=(255, 255, 255), white_value=255
        )
        common.turn_on(self.hass, ent3.entity_id, xy_color=(0.4, 0.6))

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_on")
        assert {
            light.ATTR_TRANSITION: 10,
            light.ATTR_BRIGHTNESS: 20,
            light.ATTR_HS_COLOR: (240, 100),
        } == data

        _, data = ent2.last_call("turn_on")
        assert {light.ATTR_HS_COLOR: (0, 0), light.ATTR_WHITE_VALUE: 255} == data

        _, data = ent3.last_call("turn_on")
        assert {light.ATTR_HS_COLOR: (71.059, 100)} == data

        # Ensure attributes are filtered when light is turned off
        common.turn_on(
            self.hass, ent1.entity_id, transition=10, brightness=0, color_name="blue"
        )
        common.turn_on(
            self.hass,
            ent2.entity_id,
            brightness=0,
            rgb_color=(255, 255, 255),
            white_value=0,
        )
        common.turn_on(self.hass, ent3.entity_id, brightness=0, xy_color=(0.4, 0.6))

        self.hass.block_till_done()

        assert not light.is_on(self.hass, ent1.entity_id)
        assert not light.is_on(self.hass, ent2.entity_id)
        assert not light.is_on(self.hass, ent3.entity_id)

        _, data = ent1.last_call("turn_off")
        assert {light.ATTR_TRANSITION: 10} == data

        _, data = ent2.last_call("turn_off")
        assert {} == data

        _, data = ent3.last_call("turn_off")
        assert {} == data

        # One of the light profiles
        prof_name, prof_h, prof_s, prof_bri = "relax", 35.932, 69.412, 144

        # Test light profiles
        common.turn_on(self.hass, ent1.entity_id, profile=prof_name)
        # Specify a profile and a brightness attribute to overwrite it
        common.turn_on(self.hass, ent2.entity_id, profile=prof_name, brightness=100)

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_on")
        assert {
            light.ATTR_BRIGHTNESS: prof_bri,
            light.ATTR_HS_COLOR: (prof_h, prof_s),
        } == data

        _, data = ent2.last_call("turn_on")
        assert {
            light.ATTR_BRIGHTNESS: 100,
            light.ATTR_HS_COLOR: (prof_h, prof_s),
        } == data

        # Test bad data
        common.turn_on(self.hass)
        common.turn_on(self.hass, ent1.entity_id, profile="nonexisting")
        common.turn_on(self.hass, ent2.entity_id, xy_color=["bla-di-bla", 5])
        common.turn_on(self.hass, ent3.entity_id, rgb_color=[255, None, 2])

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_on")
        assert {} == data

        _, data = ent2.last_call("turn_on")
        assert {} == data

        _, data = ent3.last_call("turn_on")
        assert {} == data

        # faulty attributes will not trigger a service call
        common.turn_on(
            self.hass, ent1.entity_id, profile=prof_name, brightness="bright"
        )
        common.turn_on(self.hass, ent1.entity_id, rgb_color="yellowish")
        common.turn_on(self.hass, ent2.entity_id, white_value="high")

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_on")
        assert {} == data

        _, data = ent2.last_call("turn_on")
        assert {} == data

    def test_broken_light_profiles(self):
        """Test light profiles."""
        platform = getattr(self.hass.components, "test.light")
        platform.init()

        user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)

        # Setup a wrong light file
        with open(user_light_file, "w") as user_file:
            user_file.write("id,x,y,brightness\n")
            user_file.write("I,WILL,NOT,WORK\n")

        assert not setup_component(
            self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
        )

    def test_light_profiles(self):
        """Test light profiles."""
        platform = getattr(self.hass.components, "test.light")
        platform.init()

        user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)

        with open(user_light_file, "w") as user_file:
            user_file.write("id,x,y,brightness\n")
            user_file.write("test,.4,.6,100\n")
            user_file.write("test_off,0,0,0\n")

        assert setup_component(
            self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
        )

        ent1, _, _ = platform.ENTITIES

        common.turn_on(self.hass, ent1.entity_id, profile="test")

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_on")

        assert light.is_on(self.hass, ent1.entity_id)
        assert {light.ATTR_HS_COLOR: (71.059, 100), light.ATTR_BRIGHTNESS: 100} == data

        common.turn_on(self.hass, ent1.entity_id, profile="test_off")

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_off")

        assert not light.is_on(self.hass, ent1.entity_id)
        assert {} == data

    def test_default_profiles_group(self):
        """Test default turn-on light profile for all lights."""
        platform = getattr(self.hass.components, "test.light")
        platform.init()

        user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
        real_isfile = os.path.isfile
        real_open = open

        def _mock_isfile(path):
            if path == user_light_file:
                return True
            return real_isfile(path)

        def _mock_open(path, *args, **kwargs):
            if path == user_light_file:
                return StringIO(profile_data)
            return real_open(path, *args, **kwargs)

        profile_data = "id,x,y,brightness\n" + "group.all_lights.default,.4,.6,99\n"
        with mock.patch("os.path.isfile", side_effect=_mock_isfile):
            with mock.patch("builtins.open", side_effect=_mock_open):
                with mock_storage():
                    assert setup_component(
                        self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
                    )

        ent, _, _ = platform.ENTITIES
        common.turn_on(self.hass, ent.entity_id)
        self.hass.block_till_done()
        _, data = ent.last_call("turn_on")
        assert {light.ATTR_HS_COLOR: (71.059, 100), light.ATTR_BRIGHTNESS: 99} == data

    def test_default_profiles_light(self):
        """Test default turn-on light profile for a specific light."""
        platform = getattr(self.hass.components, "test.light")
        platform.init()

        user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)
        real_isfile = os.path.isfile
        real_open = open

        def _mock_isfile(path):
            if path == user_light_file:
                return True
            return real_isfile(path)

        def _mock_open(path, *args, **kwargs):
            if path == user_light_file:
                return StringIO(profile_data)
            return real_open(path, *args, **kwargs)

        profile_data = (
            "id,x,y,brightness\n"
            + "group.all_lights.default,.3,.5,200\n"
            + "light.ceiling_2.default,.6,.6,100\n"
        )
        with mock.patch("os.path.isfile", side_effect=_mock_isfile):
            with mock.patch("builtins.open", side_effect=_mock_open):
                with mock_storage():
                    assert setup_component(
                        self.hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
                    )

        dev = next(
            filter(lambda x: x.entity_id == "light.ceiling_2", platform.ENTITIES)
        )
        common.turn_on(self.hass, dev.entity_id)
        self.hass.block_till_done()
        _, data = dev.last_call("turn_on")
        assert {light.ATTR_HS_COLOR: (50.353, 100), light.ATTR_BRIGHTNESS: 100} == data


async def test_intent_set_color(hass):
    """Test the set color intent."""
    hass.states.async_set(
        "light.hello_2", "off", {ATTR_SUPPORTED_FEATURES: light.SUPPORT_COLOR}
    )
    hass.states.async_set("switch.hello", "off")
    calls = async_mock_service(hass, light.DOMAIN, light.SERVICE_TURN_ON)
    hass.helpers.intent.async_register(light.SetIntentHandler())

    result = await hass.helpers.intent.async_handle(
        "test",
        light.INTENT_SET,
        {"name": {"value": "Hello"}, "color": {"value": "blue"}},
    )
    await hass.async_block_till_done()

    assert result.speech["plain"]["speech"] == "Changed hello 2 to the color blue"

    assert len(calls) == 1
    call = calls[0]
    assert call.domain == light.DOMAIN
    assert call.service == SERVICE_TURN_ON
    assert call.data.get(ATTR_ENTITY_ID) == "light.hello_2"
    assert call.data.get(light.ATTR_RGB_COLOR) == (0, 0, 255)


async def test_intent_set_color_tests_feature(hass):
    """Test the set color intent."""
    hass.states.async_set("light.hello", "off")
    calls = async_mock_service(hass, light.DOMAIN, light.SERVICE_TURN_ON)
    hass.helpers.intent.async_register(light.SetIntentHandler())

    try:
        await hass.helpers.intent.async_handle(
            "test",
            light.INTENT_SET,
            {"name": {"value": "Hello"}, "color": {"value": "blue"}},
        )
        assert False, "handling intent should have raised"
    except IntentHandleError as err:
        assert str(err) == "Entity hello does not support changing colors"

    assert len(calls) == 0


async def test_intent_set_color_and_brightness(hass):
    """Test the set color intent."""
    hass.states.async_set(
        "light.hello_2",
        "off",
        {ATTR_SUPPORTED_FEATURES: (light.SUPPORT_COLOR | light.SUPPORT_BRIGHTNESS)},
    )
    hass.states.async_set("switch.hello", "off")
    calls = async_mock_service(hass, light.DOMAIN, light.SERVICE_TURN_ON)
    hass.helpers.intent.async_register(light.SetIntentHandler())

    result = await hass.helpers.intent.async_handle(
        "test",
        light.INTENT_SET,
        {
            "name": {"value": "Hello"},
            "color": {"value": "blue"},
            "brightness": {"value": "20"},
        },
    )
    await hass.async_block_till_done()

    assert (
        result.speech["plain"]["speech"]
        == "Changed hello 2 to the color blue and 20% brightness"
    )

    assert len(calls) == 1
    call = calls[0]
    assert call.domain == light.DOMAIN
    assert call.service == SERVICE_TURN_ON
    assert call.data.get(ATTR_ENTITY_ID) == "light.hello_2"
    assert call.data.get(light.ATTR_RGB_COLOR) == (0, 0, 255)
    assert call.data.get(light.ATTR_BRIGHTNESS_PCT) == 20


async def test_light_context(hass, hass_admin_user):
    """Test that light context works."""
    assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})

    state = hass.states.get("light.ceiling")
    assert state is not None

    await hass.services.async_call(
        "light",
        "toggle",
        {"entity_id": state.entity_id},
        True,
        core.Context(user_id=hass_admin_user.id),
    )

    state2 = hass.states.get("light.ceiling")
    assert state2 is not None
    assert state.state != state2.state
    assert state2.context.user_id == hass_admin_user.id


async def test_light_turn_on_auth(hass, hass_admin_user):
    """Test that light context works."""
    assert await async_setup_component(hass, "light", {"light": {"platform": "test"}})

    state = hass.states.get("light.ceiling")
    assert state is not None

    hass_admin_user.mock_policy({})

    with pytest.raises(Unauthorized):
        await hass.services.async_call(
            "light",
            "turn_on",
            {"entity_id": state.entity_id},
            True,
            core.Context(user_id=hass_admin_user.id),
        )
