#
#    Copyright (c) 2023 Project CHIP Authors
#    All rights reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License");
#    you may not use this file except in compliance with the License.
#    You may obtain a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#
import logging
import re

import chip.clusters as Clusters
from matter_testing_support import MatterBaseTest, TestStep, async_test_body, default_matter_test_main
from mobly import asserts

logger = logging.getLogger(__name__)

kRootEndpointId = 0
kMaxUserActiveModeBitmap = 0x1FFFF
kMaxUserActiveModeTriggerInstructionByteLength = 128

cluster = Clusters.Objects.IcdManagement
uat = cluster.Bitmaps.UserActiveModeTriggerBitmap
modes = cluster.Enums.OperatingModeEnum
features = cluster.Bitmaps.Feature

# BitMask for all user active mode trigger hints that are depedent on the UserActiveModeTriggerInstruction
kUatInstructionDependentBitMask = uat.kCustomInstruction | uat.kActuateSensorSeconds | uat.kActuateSensorTimes | uat.kActuateSensorLightsBlink | uat.kResetButtonLightsBlink | uat.kResetButtonSeconds | uat.kResetButtonTimes | uat.kSetupButtonSeconds | uat.kSetupButtonLightsBlink | uat.kSetupButtonTimes | uat.kAppDefinedButton

# BitMask for UserActiveModeTriggerHint that REQUIRE the prescense of the UserActiveModeTriggerInstruction
kUatInstructionMandatoryBitMask = uat.kCustomInstruction | uat.kActuateSensorSeconds | uat.kActuateSensorTimes | uat.kResetButtonSeconds | uat.kResetButtonTimes | uat.kSetupButtonSeconds | uat.kSetupButtonTimes | uat.kAppDefinedButton

# BitMask for all user active mode trigger hints that have the UserActiveModeTriggerInstruction as an uint
kUatNumberInstructionBitMask = uat.kActuateSensorSeconds | uat.kActuateSensorTimes | uat.kResetButtonSeconds | uat.kResetButtonTimes | uat.kSetupButtonSeconds | uat.kSetupButtonTimes

# BitMask for all user active mode trigger hints that provide a color in the UserActiveModeTriggerInstruction
kUatColorInstructionBitMask = uat.kActuateSensorLightsBlink | uat.kResetButtonLightsBlink | uat.kSetupButtonLightsBlink


class TC_ICDM_2_1(MatterBaseTest):

    #
    # Class Helper functions
    #

    @staticmethod
    def is_valid_uint32_value(var):
        return isinstance(var, int) and 0 <= var <= 0xFFFFFFFF

    @staticmethod
    def is_valid_uint16_value(var):
        return isinstance(var, int) and 0 <= var <= 0xFFFF

    @staticmethod
    def is_valid_uint8_value(var):
        return isinstance(var, int) and 0 <= var <= 0xFF

    @staticmethod
    def set_bits_count(number):
        return bin(number).count("1")

    async def _read_icdm_attribute_expect_success(self, attribute):
        return await self.read_single_attribute_check_success(endpoint=kRootEndpointId, cluster=cluster, attribute=attribute)

    async def _wildcard_cluster_read(self):
        return await self.default_controller.ReadAttribute(self.dut_node_id, [(kRootEndpointId, cluster)])

    #
    # Test Harness Helpers
    #

    def desc_TC_ICDM_2_1(self) -> str:
        """Returns a description of this test"""
        return "[TC_ICDM_2_1]  attributes with DUT as Server"

    def steps_TC_ICDM_2_1(self) -> list[TestStep]:
        steps = [
            TestStep(1, "Commissioning, already done", is_commissioning=True),
            TestStep(2, "TH reads from the DUT the ActiveModeThreshold attribute."),
            TestStep(3, "TH reads from the DUT the ActiveModeDuration attribute."),
            TestStep(4, "TH reads from the DUT the IdleModeDuration attribute."),
            TestStep(
                5, "TH reads from the DUT the ClientsSupportedPerFabric attribute."),
            TestStep(6, "TH reads from the DUT the RegisteredClients attribute."),
            TestStep(7, "TH reads from the DUT the ICDCounter attribute."),
            TestStep(
                8, "TH reads from the DUT the UserActiveModeTriggerHint attribute."),
            TestStep(
                9, "TH reads from the DUT the UserActiveModeTriggerInstruction attribute"),
            TestStep(10, "TH reads from the DUT the OperatingMode attribute."),
        ]
        return steps

    def pics_TC_ICDM_2_1(self) -> list[str]:
        """ This function returns a list of PICS for this test case that must be True for the test to be run"""
        pics = [
            "ICDM.S",
        ]
        return pics

    #
    # ICDM 2.1 Test Body
    #

    @async_test_body
    async def test_TC_ICDM_2_1(self):

        cluster = Clusters.Objects.IcdManagement
        attributes = cluster.Attributes

        # Commissioning
        self.step(1)
        # Read feature map
        featureMap = await self._read_icdm_attribute_expect_success(
            attributes.FeatureMap)

        # Validate ActiveModeThreshold
        self.step(2)
        if self.check_pics("ICDM.S.A0002"):

            activeModeThreshold = await self._read_icdm_attribute_expect_success(
                attributes.ActiveModeThreshold)
            # Verify ActiveModeThreshold is not bigger than uint16
            asserts.assert_true(self.is_valid_uint16_value(activeModeThreshold),
                                "ActiveModeThreshold attribute does not fit in a uint16.")

            if featureMap > 0 and features.kLongIdleTimeSupport in features(featureMap):
                asserts.assert_greater_equal(
                    activeModeThreshold, 5000, "Minimum ActiveModeThreshold is 5s for a LIT ICD.")

        else:
            asserts.assert_true(
                False, "ActiveModeThreshold is a mandatory attribute and must be present in the PICS file")

        # Validate ActiveModeDuration
        self.step(3)
        if self.check_pics("ICDM.S.A0001"):
            activeModeDuration = await self._read_icdm_attribute_expect_success(
                attributes.ActiveModeDuration)
            # Verify ActiveModeDuration is not bigger than uint32
            asserts.assert_true(self.is_valid_uint32_value(activeModeDuration),
                                "ActiveModeDuration attribute does not fit in a uint32")
        else:
            asserts.assert_true(
                False, "ActiveModeDuration is a mandatory attribute and must be present in the PICS file")

        # Validate IdleModeDuration
        self.step(4)
        if self.check_pics("ICDM.S.A0000"):
            idleModeDuration = await self._read_icdm_attribute_expect_success(
                attributes.IdleModeDuration)
            # Verify IdleModeDuration is not bigger than uint32
            asserts.assert_greater_equal(
                idleModeDuration, 1, "IdleModeDuration attribute is smaller than minimum value (1).")
            asserts.assert_less_equal(
                idleModeDuration, 64800, "IdleModeDuration attribute is greater than maximum value (64800).")
            asserts.assert_greater_equal(idleModeDuration * 1000, activeModeDuration,
                                         "ActiveModeDuration attribute is greater than the IdleModeDuration attrbiute.")
        else:
            asserts.assert_true(
                False, "IdleModeDuration is a mandatory attribute and must be present in the PICS file")

        # Validate ClientsSupportedPerFabric
        self.step(5)
        if self.pics_guard(self.check_pics("ICDM.S.A0005")):
            clientsSupportedPerFabric = await self._read_icdm_attribute_expect_success(
                attributes.ClientsSupportedPerFabric)

            # Verify ClientsSupportedPerFabric is not bigger than uint16
            asserts.assert_true(self.is_valid_uint16_value(clientsSupportedPerFabric),
                                "ClientsSupportedPerFabric attribute does not fit in a uint16.")

            asserts.assert_greater_equal(
                clientsSupportedPerFabric, 1, "ClientsSupportedPerFabric attribute is smaller than minimum value (1).")

        # Validate RegisteredClients
        self.step(6)
        if self.pics_guard(self.check_pics("ICDM.S.A0003")):
            registeredClients = await self._read_icdm_attribute_expect_success(
                attributes.RegisteredClients)

            asserts.assert_true(isinstance(
                registeredClients, list), "RegisteredClients is not a list.")

        # Validate ICDCounter
        self.step(7)
        if self.pics_guard(self.check_pics("ICDM.S.A0004")):

            icdCounter = await self._read_icdm_attribute_expect_success(
                attributes.ICDCounter)
            # Verify ICDCounter is not bigger than uint32
            asserts.assert_true(self.is_valid_uint32_value(icdCounter),
                                "ActiveModeDuration attribute does not fit in a uint32")

        # Validate UserActiveModeTriggerHint
        self.step(8)
        if self.pics_guard(self.check_pics("ICDM.S.A0006")):
            userActiveModeTriggerHint = await self._read_icdm_attribute_expect_success(
                attributes.UserActiveModeTriggerHint)

            # Verify that it is a bitmap32 - Only the first 16 bits are used
            asserts.assert_true(0 <= userActiveModeTriggerHint <= kMaxUserActiveModeBitmap,
                                "UserActiveModeTriggerHint attribute does not fit in a bitmap32")

            # Verify that only a single UserActiveModeTriggerInstruction dependent bit is set
            uatHintInstructionDepedentBitmap = uat(
                userActiveModeTriggerHint) & kUatInstructionDependentBitMask

        asserts.assert_less_equal(
            self.set_bits_count(uatHintInstructionDepedentBitmap), 1, "UserActiveModeTriggerHint has more than 1 bit that is dependent on the UserActiveModeTriggerInstruction")

        # Valdate UserActiveModeTriggerInstruction
        self.step(9)
        if self.check_pics("ICDM.S.A0007"):
            userActiveModeTriggerInstruction = await self._read_icdm_attribute_expect_success(
                attributes.UserActiveModeTriggerInstruction)

            # Verify that the UserActiveModeTriggerInstruction has the correct encoding
            try:
                encodedUATInstruction = userActiveModeTriggerInstruction.encode(
                    'utf-8')
            except Exception:
                asserts.assert_true(
                    False, "UserActiveModeTriggerInstruction is not encoded in the correct format (utf-8).")

            # Verify byte length of the UserActiveModeTirggerInstruction
            asserts.assert_less_equal(
                len(encodedUATInstruction), kMaxUserActiveModeTriggerInstructionByteLength, "UserActiveModeTriggerInstruction is longuer than the maximum allowed length (128).")

            if uatHintInstructionDepedentBitmap > 0 and uatHintInstructionDepedentBitmap in kUatNumberInstructionBitMask:
                # Validate Instruction is a decimal unsigned integer using the ASCII digits 0-9, and without leading zeros.
                asserts.assert_true((re.search(r'^(?!0)[0-9]*$', userActiveModeTriggerInstruction) is not None),
                                    "UserActiveModeTriggerInstruction is not in the correct format for the associated UserActiveModeTriggerHint")

            if uatHintInstructionDepedentBitmap > 0 and uatHintInstructionDepedentBitmap in kUatColorInstructionBitMask:
                # TODO: https://github.com/CHIP-Specifications/connectedhomeip-spec/issues/9194
                asserts.assert_true(False, "Nothing to do for now")
        else:
            # Check if the UserActiveModeTriggerInstruction was required
            asserts.assert_false(uatHintInstructionDepedentBitmap in kUatInstructionMandatoryBitMask,
                                 "UserActiveModeTriggerHint requires the UserActiveModeTriggerInstruction")

        # Verify OperatingMode
        self.step(10)
        if self.pics_guard(self.check_pics("ICDM.S.A0008")):
            operatingMode = await self._read_icdm_attribute_expect_success(
                attributes.OperatingMode)

            asserts.assert_true(self.is_valid_uint8_value(operatingMode),
                                "OperatingMode does not fit in an enum8")

            asserts.assert_less(
                operatingMode, modes.kUnknownEnumValue, "OperatingMode can only have 0 and 1 as valid values")


if __name__ == "__main__":
    default_matter_test_main()