from __future__ import annotations

import asyncio
import hashlib
import json
import logging
import re
import typing
import xml.etree.ElementTree as ET
from abc import ABC, abstractmethod
from asyncio import Task
from datetime import datetime, timedelta
from enum import IntFlag, Enum, auto
from typing import Optional, Tuple, Dict, List, Union, TypedDict
from urllib.parse import urlencode

import requests


class WeekDay(IntFlag):
    MON = 0b1
    TUE = 0b10
    WED = 0b100
    THU = 0b1000
    FRI = 0b10000
    SAT = 0b100000
    SUN = 0b1000000


class Manufacturer:
    def __init__(self, name: str):
        self.name: str = name

    def __repr__(self):
        return f"name: {self.name}"

    def to_json(self):
        return {"name": self.name}

    @staticmethod
    def parse_dict(manufacturer: Dict):
        return Manufacturer(manufacturer["name"])


class FirmwareVersion:
    def __init__(self, search: bool, current: str, update: bool, running: bool):
        self.search: bool = search
        self.current: str = current
        self.update: bool = update
        self.running: bool = running

    def __repr__(self):
        return f"search: {self.search}; current: {self.current}; update: {self.update}; running: {self.running}"

    def to_json(self):
        return {"search": self.search, "current": self.current, "update": self.update, "running": self.running}

    @staticmethod
    def parse_dict(firmware_version: dict):
        return FirmwareVersion(firmware_version["search"],
                               firmware_version["current"],
                               firmware_version["update"],
                               firmware_version["running"])


class PushService:
    def __init__(self, mail_address: str, unit_settings: List, is_enabled: bool):
        self.mail_address: str = mail_address
        self.unit_settings: List = unit_settings
        self.is_enabled: bool = is_enabled

    def __repr__(self):
        return f"<PushService MailAddress: {self.mail_address}; UnitSettings: {self.unit_settings}; " \
               f"isEnabled: {self.is_enabled}>"

    def to_json(self):
        return {"mailAddress": self.mail_address, "unitSettings": self.unit_settings, "isEnabled": self.is_enabled}

    @staticmethod
    def parse_dict(push_service: Dict):
        return PushService(push_service["mailAddress"], push_service["unitSettings"], push_service["isEnabled"])


class SkillType(Enum):
    SmartHomeTemperatureSensor = auto()
    SmartHomeThermostat = auto()
    SmartHomeBattery = auto()


class Skill(ABC):
    def __init__(self, skill_type: SkillType):
        self.type: SkillType = skill_type

    @abstractmethod
    def to_json(self):
        pass

    @abstractmethod
    def to_web_data(self, device_id: int):
        pass

    @staticmethod
    def parse_dict(skill: Dict):
        skill_type = SkillType[skill["type"]]
        if skill_type == SkillType.SmartHomeTemperatureSensor:
            return TemperatureSkill.parse_dict(skill)
        elif skill_type == SkillType.SmartHomeThermostat:
            return ThermostatSkill.parse_dict(skill)
        elif skill_type == SkillType.SmartHomeBattery:
            return BatterySkill.parse_dict(skill)
        else:
            raise NotImplementedError(skill_type)


class PresetName(Enum):
    LOWER_TEMPERATURE = auto()
    UPPER_TEMPERATURE = auto()
    HOLIDAY_TEMPERATURE = auto()


class Preset:
    def __init__(self, name: PresetName, temperature: int):
        self.name: PresetName = name
        self.temperature: int = temperature

    def __repr__(self):
        return f"<Preset name: {self.name.name}; temperature: {self.temperature}>"

    def to_json(self):
        return {"name": self.name.name, "temperature": self.temperature}


class Description:
    def __init__(self, action: str, preset_temperature: Optional[Preset]):
        self.action: str = action
        self.preset_temperature: Optional[Preset] = preset_temperature

    def __repr__(self):
        desc = f"<Description action: {self.action}"
        if self.preset_temperature is not None:
            desc += f"; presetTemperaturet: {self.preset_temperature}"
        desc += " >"

        return desc

    def to_json(self):
        if self.preset_temperature is not None:
            return {"action": self.action, "presetTemperature": self.preset_temperature.to_json()}
        return {"action": self.action}

    @staticmethod
    def parse_dict(description: Dict):
        preset: Optional[Preset] = None
        if "presetTemperature" in description.keys():
            preset = Preset(PresetName[description["presetTemperature"]["name"]],
                            description["presetTemperature"]["temperature"])
        return Description(description["action"], preset)


class Repetition(Enum):
    NONE = auto()
    YEARLY = auto()


class TimeSetting:
    def __init__(self, start_date: Optional[str], start_time: Optional[str],
                 end_date: Optional[str] = None, end_time: Optional[str] = None,
                 repetition: Repetition = Repetition.NONE, day_of_week: Optional[WeekDay] = None):
        self.start_date: Optional[str] = start_date
        self.start_time: Optional[str] = start_time
        self.end_date: Optional[str] = end_date
        self.end_time: Optional[str] = end_time
        self.repetition: Repetition = repetition
        self.day_of_week: Optional[WeekDay] = day_of_week

    def __repr__(self):
        desc = f"<TimeSettings "
        if self.day_of_week is not None:
            desc += f"dayOfWeek: {self.day_of_week.name}; "
        if self.start_date is not None:
            desc += f"startDate: {self.start_date} "
        if self.start_time is not None:
            desc += f"startTime: {self.start_time} "
        if self.end_date is not None:
            desc += f"endDate: {self.end_date} "
        if self.end_time is not None:
            desc += f"endTime: {self.end_time} "
        if self.repetition != Repetition.NONE:
            desc += f"repetition: {self.repetition.name} "
        desc += ">"

        return desc

    def to_json(self):  # ToDo: Return typehints for all to_json
        state = {}
        if self.start_date is not None:
            state["startDate"] = self.start_date
        if self.start_time is not None:
            state["startTime"] = self.start_time
        if self.end_date is not None:
            state["endDate"] = self.end_date
        if self.end_time is not None:
            state["endTime"] = self.end_time
        if self.repetition != Repetition.NONE:
            state["repetition"] = self.repetition.name
        if self.day_of_week is not None:
            state = {"dayOfWeek": self.day_of_week.name,
                     "time": state}

        return state

    @staticmethod
    def parse_dict(time_setting: Dict):
        start_date: Optional[str] = None
        start_time: Optional[str] = None
        end_date: Optional[str] = None
        end_time: Optional[str] = None
        day_of_week: Optional[WeekDay] = None
        repetition: Repetition = Repetition.NONE
        if "dayOfWeek" in time_setting.keys():
            day_of_week = WeekDay[time_setting["dayOfWeek"]]
            time_setting = time_setting["time"]
        if "startDate" in time_setting.keys():
            start_date = time_setting["startDate"]
        if "startTime" in time_setting.keys():
            start_time = time_setting["startTime"]
        if "endDate" in time_setting.keys():
            end_date = time_setting["endDate"]
        if "endTime" in time_setting.keys():
            end_time = time_setting["endTime"]
        if "repetition" in time_setting.keys():
            repetition = Repetition[time_setting["repetition"]]

        return TimeSetting(start_date, start_time, end_date, end_time, repetition, day_of_week)


class Change:
    def __init__(self, description: Description, time_setting: TimeSetting):
        self.description: Description = description
        self.time_setting: TimeSetting = time_setting

    def __repr__(self):
        return f"<Change description: {self.description}; timeSetting: {self.time_setting}>"

    def to_json(self):
        return {"description": self.description.to_json(), "timeSetting": self.time_setting.to_json()}

    @staticmethod
    def parse_dict(change: Dict):
        return Change(Description.parse_dict(change["description"]), TimeSetting.parse_dict(change["timeSetting"]))


class TemperatureDropDetection:
    def __init__(self, do_not_heat_offset_in_minutes: int, sensitivity: int, is_window_open: bool):
        self.do_not_heat_offset_in_minutes: int = do_not_heat_offset_in_minutes
        self.sensitivity: int = sensitivity
        self.is_window_open: bool = is_window_open

    def __repr__(self):
        # ToDo
        pass

    def to_json(self):
        return {
            "doNotHeatOffsetInMinutes": self.do_not_heat_offset_in_minutes,
            "sensitivity": self.sensitivity,
            "isWindowOpen": self.is_window_open
        }

    def to_web_data(self, device_id: int):
        return {
            "WindowOpenTrigger": self.sensitivity + 3,
            "WindowOpenTimer": self.do_not_heat_offset_in_minutes
        }

    @staticmethod
    def parse_dict(drop_detection: Dict):
        return TemperatureDropDetection(drop_detection["doNotHeatOffsetInMinutes"],
                                        drop_detection["sensitivity"],
                                        drop_detection["isWindowOpen"])


class ScheduleKind(Enum):
    REPETITIVE = auto()
    WEEKLY_TIMETABLE = auto()


class ThermostatSkillMode(Enum):
    TARGET_TEMPERATURE = auto()


class Action:
    def __init__(self, is_enabled: bool, time_setting: TimeSetting, description: Description):
        self.is_enabled: bool = is_enabled
        self.time_setting: TimeSetting = time_setting
        self.description: Description = description

    def __repr__(self):
        return f"<Action isEnabled: {self.is_enabled}; timeSetting: {self.time_setting}; " \
               f"description: {self.description} >"

    def to_json(self):
        return {"isEnabled": self.is_enabled,
                "timeSetting": self.time_setting.to_json(),
                "description": self.description.to_json()}

    @staticmethod
    def parse_dict(action: Dict):
        return Action(action["isEnabled"], TimeSetting.parse_dict(action["timeSetting"]),
                      Description.parse_dict(action["description"]))


class Schedule:
    def __init__(self, is_enabled: bool, kind: ScheduleKind, name: str, actions: List[Action]):
        self.is_enabled: bool = is_enabled
        self.kind: ScheduleKind = kind
        self.name: str = name
        self.actions: List[Action] = actions

    def __repr__(self):
        return f"<Schedule isEnabled: {self.is_enabled}; kind: {self.kind.name}; " \
               f"name: {self.name}; actions: {self.actions}>"

    def to_json(self):
        return {
            "isEnabled": self.is_enabled,
            "kind": self.kind.name,
            "name": self.name,
            "actions": [action.to_json() for action in self.actions]
        }

    def to_web_data(self, device_id: int):
        data = {}
        if self.kind == ScheduleKind.REPETITIVE and self.name == "HOLIDAYS":  # ToDo: Enum for names?
            enabled_count = 0
            for num, holiday in enumerate(self.actions):
                num += 1
                _, start_month, start_day = holiday.time_setting.start_date.split("-")
                _, end_month, end_day = holiday.time_setting.end_date.split("-")
                data.update({
                    f"Holiday{num}StartDay": start_day,
                    f"Holiday{num}StartMonth": start_month,
                    f"Holiday{num}StartHour": holiday.time_setting.start_time.split(":")[0],
                    f"Holiday{num}EndDay": end_day,
                    f"Holiday{num}EndMonth": end_month,
                    f"Holiday{num}EndHour": holiday.time_setting.end_time.split(":")[0],
                    f"Holiday{num}Enabled": 1 if holiday.is_enabled else 0,
                    f"Holiday{num}ID": num
                })
                if holiday.is_enabled:
                    enabled_count += 1
            data["HolidayEnabledCount"] = enabled_count
        elif self.kind == ScheduleKind.REPETITIVE and self.name == "SUMMER_TIME":
            _, start_month, start_day = self.actions[0].time_setting.start_date.split("-")
            _, end_month, end_day = self.actions[0].time_setting.end_date.split("-")
            data = {
                "SummerStartDay": start_day,
                "SummerStartMonth": start_month,
                "SummerEndDay": end_day,
                "SummerEndMonth": end_month,
                "SummerEnabled": 1 if self.is_enabled else 0
            }
        elif self.kind == ScheduleKind.WEEKLY_TIMETABLE and self.name == "TEMPERATURE":
            timer_items = {}
            for action in self.actions:
                if not action.is_enabled:
                    continue
                time = "".join(action.time_setting.start_time.split(":")[:-1])
                if time not in timer_items.keys():
                    timer_items[time] = [0, 0]
                heat = 1 if action.description.preset_temperature.name == PresetName.UPPER_TEMPERATURE else 0
                days = timer_items[time][heat]
                days |= action.time_setting.day_of_week
                timer_items[time][heat] = days
            num = 0
            for key in timer_items.keys():
                if timer_items[key][0] != 0:
                    data.update({f"timer_item_{num}": f"{key};0;{timer_items[key][0].as_integer_ratio()[0]}"})
                    num += 1
                if timer_items[key][1] != 0:
                    data.update({f"timer_item_{num}": f"{key};1;{timer_items[key][1].as_integer_ratio()[0]}"})
                    num += 1
        else:
            raise NotImplementedError(self.name)

        return data

    @staticmethod
    def parse_dict(schedule: Dict):  # ToDo: Make TypedDicts for all those dicts
        return Schedule(schedule["isEnabled"],
                        ScheduleKind[schedule["kind"]],
                        schedule["name"],
                        [Action.parse_dict(action) for action in schedule["actions"]])


class TimeControl:
    def __init__(self, is_enabled: bool, time_schedules: List[Schedule]):
        self.is_enabled: bool = is_enabled
        self.time_schedules: List[Schedule] = time_schedules

    def __repr__(self):
        return f"<TimeControl isEnabled: {self.is_enabled}; timeSchedules: {self.time_schedules}"

    def to_json(self):
        return {
            "isEnabled": self.is_enabled,
            "timeSchedules": [schedule.to_json() for schedule in self.time_schedules]
        }

    def to_web_data(self, device_id: int):
        data = {}
        for schedule in self.time_schedules:
            data.update(schedule.to_web_data(device_id))
        return data

    @staticmethod
    def parse_dict(time_control: Dict):
        return TimeControl(time_control["isEnabled"],
                           [Schedule.parse_dict(schedule) for schedule in time_control["timeSchedules"]])


class ThermostatSkill(Skill):
    def __init__(self, presets: List[Preset], next_change: Optional[Change],
                 temperature_drop_detection: TemperatureDropDetection,
                 target_temp: int, time_control: TimeControl, holiday_active: bool,
                 mode: ThermostatSkillMode, summer_active: bool, used_temp_sensor: Unit):
        super().__init__(SkillType.SmartHomeThermostat)
        self.presets: List[Preset] = presets
        self.next_change: Optional[Change] = next_change
        self.temperature_drop_detection: TemperatureDropDetection = temperature_drop_detection
        self.target_temp: int = target_temp
        self.time_control: TimeControl = time_control
        self.holiday_active: bool = holiday_active
        self.mode: ThermostatSkillMode = mode
        self.summer_active: bool = summer_active
        self.used_temp_sensor: Unit = used_temp_sensor

    def __repr__(self):
        # ToDo
        pass

    def to_web_data(self, device_id: int):
        upper = 0.0
        lower = 0.0
        for preset in self.presets:
            if preset.name == PresetName.UPPER_TEMPERATURE:
                upper = preset.temperature
            elif preset.name == PresetName.LOWER_TEMPERATURE:
                lower = preset.temperature

        data = {
            "Heiztemp": upper,
            "Absenktemp": lower
        }

        if device_id == self.used_temp_sensor.id:
            data.update({"ExtTempsensorID": "tochoose", "tempsensor": "own"})
        else:
            data.update({"ExtTempsensorID": self.used_temp_sensor.id, "tempsensor": "extern"})

        data.update(self.time_control.to_web_data(device_id))

        data.update(self.temperature_drop_detection.to_web_data(device_id))

        return data

    def to_json(self):
        state = {
            "type": self.type.name,
            "presets": [preset.to_json() for preset in self.presets],
            "temperatureDropDetection": self.temperature_drop_detection.to_json(),
            "targetTemp": self.target_temp,
            "timeControl": self.time_control.to_json(),
            "holidayActive": self.holiday_active,
            "mode": self.mode.name,
            "summerActive": self.summer_active,
            "usedTempSensor": self.used_temp_sensor.to_json()
        }
        if self.next_change is not None:
            state["nextChange"] = self.next_change.to_json()

        return state

    @staticmethod
    def parse_dict(skill: Dict):
        return ThermostatSkill(
            [Preset(PresetName[preset["name"]], preset["temperature"]) for preset in skill["presets"]],
            Change.parse_dict(skill["nextChange"]) if "nextChange" in skill.keys() else None,
            TemperatureDropDetection.parse_dict(skill["temperatureDropDetection"]),
            skill["targetTemp"],
            TimeControl.parse_dict(skill["timeControl"]),
            skill["holidayActive"],
            ThermostatSkillMode[skill["mode"]],
            skill["summerActive"],
            Unit.parse_dict(skill["usedTempSensor"], None)
        )


class TemperatureSkill(Skill):
    def __init__(self, offset: float, current_in_celsius: int):
        super().__init__(SkillType.SmartHomeTemperatureSensor)
        self.offset: float = offset
        self.current_in_celsius: int = current_in_celsius

    def __repr__(self):
        return f"{self.type.name}: " \
               f"offset: {self.offset}; currentInCelsius: {self.current_in_celsius}"

    def to_json(self):
        return {
            "type": self.type.name,
            "offset": self.offset,
            "currentInCelsius": self.current_in_celsius
        }

    def to_web_data(self, device_id: int):
        data = {
            "Roomtemp": self.current_in_celsius,
            "Offset": self.offset
        }
        return data

    @staticmethod
    def parse_dict(skill: Dict):
        return TemperatureSkill(skill["offset"], skill["currentInCelsius"])


class BatterySkill(Skill):
    def __init__(self, charge_level_in_percent: int):
        super().__init__(SkillType.SmartHomeBattery)
        self.charge_level_in_percent: int = charge_level_in_percent

    def __repr__(self):
        return f"{self.type.name}: chargeLevelInPercent: {self.charge_level_in_percent}"

    def to_json(self):
        return {"type": self.type.name, "chargeLevelInPercent": self.charge_level_in_percent}

    def to_web_data(self, device_id: int):
        return {}

    @staticmethod
    def parse_dict(skill: Dict):
        return BatterySkill(skill["chargeLevelInPercent"])


class UnitTypes(Enum):
    BATTERY = auto()
    TEMPERATURE_SENSOR = auto()
    THERMOSTAT = auto()


class Unit:
    def __init__(self, unit_type: UnitTypes, idx: int, display_name: str,
                 device: Optional[Device], skills: List[Union[Dict, Skill]],
                 actor_identification_number: str, interaction_controls: Optional[List] = None):
        self.type: UnitTypes = unit_type
        self.id: int = idx
        self.display_name: str = display_name
        self.device: Optional[Device] = device
        self.skills: List[Skill] = skills
        self.actor_identification_number: str = actor_identification_number
        self.interaction_controls: Optional[List] = interaction_controls  # ToDo: Type for this

    def __repr__(self):
        desc = f"type: {self.type.name}; id: {self.id}; displayName: {self.display_name};"
        if self.device is not None:
            desc += f"device: {self.device.short_description()}; "
        desc += f"skills: {self.skills}; "
        if self.interaction_controls is not None:
            desc += f"interactionControls: {self.interaction_controls} ;"
        desc += f"actorIdentificationNumber: {self.actor_identification_number}"
        return desc

    def to_json(self):
        state = {
            "type": self.type.name,
            "id": self.id,
            "displayName": self.display_name,
            "skills": [skill.to_json() for skill in self.skills],
            "actorIdentificationNumber": self.actor_identification_number
        }
        if self.device is not None:
            state["device"] = self.device.to_short_json()
        if self.interaction_controls is not None:
            state["interactionControls"] = self.interaction_controls

        return state

    def to_web_data(self, device_id: int):
        data = {}
        for skill in self.skills:
            data.update(skill.to_web_data(device_id))

        return data

    @staticmethod
    def parse_dict(unit: Dict, device: Optional[Device]):
        return Unit(UnitTypes[unit["type"]],
                    unit["id"],
                    unit["displayName"],
                    device,
                    [Skill.parse_dict(skill) for skill in unit["skills"]],
                    unit["actorIdentificationNumber"],
                    unit["interactionControls"] if "interactionControls" in unit.keys() else None)


class DeviceType(Enum):
    SmartHomeDevice = auto()


class DeviceCategory(Enum):
    THERMOSTAT = auto()


class Device:
    def __init__(self, state):
        self.type: Optional[DeviceType] = None
        self.is_deletable: bool = False
        self.id: int = -1
        self.master_connection_state = None  # ToDo
        self.display_name: Optional[str] = None
        self.category: Optional[str] = None
        self.units = None  # ToDo
        self.firmware_version: Optional[FirmwareVersion] = None
        self.model: Optional[str] = None
        self.is_editable: bool = False
        self.manufacturer: Optional[Manufacturer] = None
        self.push_service: Optional[PushService] = None
        self.actor_identification_number: Optional[str] = None

        if state is not None:
            self.parse_state(state)

    def __repr__(self):
        # ToDo
        pass

    def short_description(self):
        desc = f"masterConnectionState: {self.master_connection_state}; " \
               f"type: {self.type}; model: {self.model}; id: {self.id}; " \
               f"manufacturer: {self.manufacturer}; " \
               f"actorIdentificationNumber: {self.actor_identification_number}; " \
               f"displayName: {self.display_name}"

        return desc

    def parse_state(self, state):
        self.type = DeviceType[state["type"]]
        self.is_deletable = state["isDeletable"]
        self.id = state["id"]
        self.master_connection_state = state["masterConnectionState"]
        self.display_name = state["displayName"]
        self.category = state["category"]
        self.units = [Unit.parse_dict(unit, self) for unit in state["units"]]
        self.firmware_version = FirmwareVersion.parse_dict(state["firmwareVersion"])
        self.model = state["model"]
        self.is_editable = state["isEditable"]
        self.manufacturer = Manufacturer.parse_dict(state["manufacturer"])
        self.push_service = PushService.parse_dict(state["pushService"])
        self.actor_identification_number = state["actorIdentificationNumber"]

    def to_web_data(self):
        data = {
            "device": self.id,
            "ule_device_name": self.display_name
        }
        for unit in self.units:
            data.update(unit.to_web_data(self.id))
        return data

    def to_json(self):
        state = {"type": self.type.name,
                 "isDeletable": self.is_deletable,
                 "id": self.id,
                 "masterConnectionState": self.master_connection_state,
                 "displayName": self.display_name,
                 "category": self.category,
                 "units": [unit.to_json() for unit in self.units],
                 "firmwareVersion": self.firmware_version.to_json(),
                 "model": self.model,
                 "isEditable": self.is_editable,
                 "manufacturer": self.manufacturer.to_json(),
                 "pushService": self.push_service.to_json(),
                 "actorIdentificationNumber": self.actor_identification_number}

        return state

    def set_offset(self, offset: float):
        temp_sensor: Optional[Unit] = None
        for unit in self.units:
            if unit.type == UnitTypes.TEMPERATURE_SENSOR:
                temp_sensor = unit
                break
        temp_skill: Optional[TemperatureSkill] = None
        for skill in temp_sensor.skills:
            if skill.type == SkillType.SmartHomeTemperatureSensor:
                temp_skill = typing.cast(TemperatureSkill, skill)
                break
        temp_skill.offset = offset

    def get_offset(self):
        temp_sensor: Optional[Unit] = None
        for unit in self.units:
            if unit.type == UnitTypes.TEMPERATURE_SENSOR:
                temp_sensor = unit
                break
        temp_skill: Optional[TemperatureSkill] = None
        for skill in temp_sensor.skills:
            if skill.type == SkillType.SmartHomeTemperatureSensor:
                temp_skill = typing.cast(TemperatureSkill, skill)
                break
        return temp_skill.offset

    def get_temperature(self):
        temp_sensor: Optional[Unit] = None
        for unit in self.units:
            if unit.type == UnitTypes.TEMPERATURE_SENSOR:
                temp_sensor = unit
                break
        temp_skill: Optional[TemperatureSkill] = None
        for skill in temp_sensor.skills:
            if skill.type == SkillType.SmartHomeTemperatureSensor:
                temp_skill = typing.cast(TemperatureSkill, skill)
                break
        return temp_skill.current_in_celsius

    def to_short_json(self):
        return {
            "masterConnectionState": self.master_connection_state,
            "type": self.type.name,
            "model": self.model,
            "id": self.id,
            "manufacturer": self.manufacturer.to_json(),
            "actorIdentificationNumber": self.actor_identification_number,
            "displayName": self.display_name
        }


class FritzBox:
    def __init__(self, url: str, password: str, update_timeout: int, user: str = None, dry_run: bool = False) -> None:
        self._endpoints = {
            "login": "login_sid.lua?version=2",
            "logout": "index.lua",
            "data": "data.lua"
        }
        self.url: str = url
        self.dry_run: bool = dry_run
        self.user: Optional[str] = user
        self.session: requests.Session = requests.Session()
        self.password: str = password
        self.sid: Optional[str] = None
        self.update_timeout: int = update_timeout
        self.update_time: Dict[str, datetime] = {}
        self.hold_connection: Optional[Task] = None

    async def hold_connection_alive(self) -> None:
        while True:
            # Session automatically destroyed after 20m of inactivity
            await asyncio.sleep(19 * 60)
            self.check_session()

    def _calc_challenge_v2(self, challenge: str) -> str:

        logging.debug(f"Calculate v2 challenge: {challenge}")
        chall_regex = re.compile(
            "2\$(?P<iter1>[0-9a-zA-Z]+)\$(?P<salt1>[0-9a-zA-Z]+)\$(?P<iter2>[0-9a-zA-Z]+)\$(?P<salt2>[0-9a-zA-Z]+)")

        chall_parts = chall_regex.match(challenge).groupdict()
        salt1: bytes = bytes.fromhex(chall_parts["salt1"])
        iter1: int = int(chall_parts["iter1"])
        salt2: bytes = bytes.fromhex(chall_parts["salt2"])
        iter2: int = int(chall_parts["iter2"])

        hash1 = hashlib.pbkdf2_hmac('sha256', self.password.encode(), salt1, iter1)
        response = salt2.hex() + "$" + hashlib.pbkdf2_hmac('sha256', hash1, salt2, iter2).hex()

        return response

    def _calc_challenge_v1(self, challenge: str) -> str:
        """ Calculate the response for a challenge using legacy MD5 """
        logging.debug(f"Calculate v1 challenge: {challenge}")
        response = f"{challenge}-{self.password}"
        response = response.encode("utf_16_le")
        response = challenge + "-" + hashlib.md5(response).hexdigest()
        return response

    def check_session(self) -> None:
        data = {
            "xhr": 1,
            "sid": self.sid,
            "lang": "de",
            "page": "overview",
            "xhrId": "first",
            "noMenuRef": 1
        }
        r = self.session.post(f"{self.url}/{self._endpoints['data']}", data=data)
        if len(r.history) > 0:
            if not self.login():
                logging.error("Failed to login to Fritz!Box")
        else:
            logging.info("Already logged in")

    def login(self, user: str = None) -> bool:
        logging.info(f"Login user {user} to Fritz!Box")
        challenge = None
        r = self.session.get(f"{self.url}/{self._endpoints['login']}")
        xml = ET.fromstring(r.text)
        for elem in xml:
            if elem.tag == "SID":
                self.sid = elem.text
            elif elem.tag == "Challenge":
                challenge = elem.text
            elif user is None and elem.tag == "Users":
                for user_elem in elem:
                    if "fritz" in user_elem.text:
                        user = user_elem.text

        assert challenge is not None and user is not None

        if challenge.startswith("2$"):
            response = self._calc_challenge_v2(challenge)
        else:
            response = self._calc_challenge_v1(challenge)

        data = {
            "username": user,
            "response": response
        }

        r = self.session.post(f"{self.url}/{self._endpoints['login']}", data=data)
        logging.debug(r.text)
        xml = ET.fromstring(r.text)
        for elem in xml:
            if elem.tag == "SID":
                self.sid = elem.text

        logging.info(f"Authenticated Fritz!Box: {len(self.sid) != self.sid.count('0')}")
        if len(self.sid) != self.sid.count("0"):
            self.hold_connection = asyncio.create_task(self.hold_connection_alive())
        return len(self.sid) != self.sid.count("0")

    def logout(self) -> bool:
        logging.info("logout")
        data = {
            "xhr": 1,
            "sid": self.sid,
            "logout": 1,
            "no_sidrenew": ""}
        r = self.session.post(f"{self.url}/{self._endpoints['logout']}", data=data)
        if self.hold_connection is not None:
            self.hold_connection.cancel()

        return r.status_code == 200

    def list_devices(self) -> Optional[List[Device]]:
        data = {
            "xhr": 1,
            "sid": self.sid,
            "lang": "de",
            "page": "sh_dev",
            "xhrId": "all"
        }
        r = self.session.post(f"{self.url}/{self._endpoints['data']}", data=data)
        logging.debug(r.text[:100])
        if len(r.history) > 0:
            if self.login():
                r = self.session.post(f"{self.url}/{self._endpoints['data']}", data=data)
            else:
                return None
        devices: List[Device] = []
        for device in json.loads(r.text)["data"]["devices"]:
            devices.append(Device(device))

        return devices

    def get_device_data(self, idx: int = None, name: str = None) -> Optional[Device]:
        if idx is None and name is None:
            logging.debug("No id or name given")
            return None

        devices = self.list_devices()
        device = None
        for device in devices:
            if device.id == idx or device.display_name == name:
                break
            device = None

        if device is None:
            logging.debug(f"Device {idx} {name} not found")
            return None

        return device

    def set_offset(self, device: Device) -> None:
        if self.dry_run:
            logging.warning("No updates in dry-run-mode")
            return
        data = {
            "xhr": 1,
            "sid": self.sid,
            "lang": "de",
            "device": device.id,
            "page": "home_auto_hkr_edit"
        }
        self.session.post(f"{self.url}/{self._endpoints['data']}", data=data)

        data = {
            "xhr": 1,
            "sid": self.sid,
            "lang": "de",
            "view": "",
            "back_to_page": "sh_dev",
            "apply": "",
            "oldpage": "/net/home_auto_hkr_edit.lua"
        }
        data.update(device.to_web_data())

        self.session.post(f"{self.url}/{self._endpoints['data']}", data=data)

    def correct_offset(self, device_name: str, real_temp: float):
        elapsed = None
        if device_name in self.update_time.keys():
            elapsed = datetime.now() - self.update_time[device_name]
            logging.info(f"Last update for {device_name} {elapsed} ago")
        delta = timedelta(minutes=self.update_timeout)
        if device_name not in self.update_time.keys() or elapsed > delta:
            device: Optional[Device] = self.get_device_data(name=device_name)
            if device is None:
                return
            new_offset = device.get_offset() + real_temp - device.get_temperature()
            logging.info(f"Update offset from {device.get_offset()} to {new_offset}")
            device.set_offset(new_offset)
            self.set_offset(device)
            self.update_time[device.display_name] = datetime.now()