import json
from dataclasses import dataclass
from datetime import datetime

from models.HabitTrackings import HabitTrackings
from db.SQLiteClient import update_slot, create_habit, get_habit, delete_habit, get_next_slot, \
    get_habitTrackings_by_habit_id, get_slots, update_habit, get_habitList


# Unit wird als Integers wie folgt gemessen:
# 0: Tag
# 1: Woche (Default)
# 2: Monat
# 3: Jahr

@dataclass
class Habit:
    id: int
    list_id: int
    name: str
    note: str
    times: int
    unit: int
    slot: int
    percentage: int = 0

    def __post_init__(self):
        self.fill_statistics()

    @staticmethod
    def create(list_id: int, name: str, times: int, note: str | None = None, unit: int | None = 1):
        slot = get_next_slot(list_id)
        id = create_habit(list_id, name, times, unit, slot, note)
        return Habit(id, list_id, name, note, times, unit, slot)

    @staticmethod
    def get(id: int):
        habit = get_habit(id)
        habit = Habit(habit[0], habit[1], habit[2], habit[3], habit[4], habit[5], habit[6]) if habit else None

        return habit

    def update(self, name: str=None, note: str=None, times: int=None, unit: int=None):
        update_habit(self.id, name, note, times, unit)
        if name is not None:
            self.name = name
        if note is not None:
            self.note = note
        if times is not None:
            self.times = times
        if unit is not None:
            self.unit = unit

    def update_slot(self, new_slot: int):
        slots = get_slots(self.list_id)
        if new_slot > self.slot:
            slots = slots[self.slot:new_slot]
            for slot in slots:
                update_slot(slot[0], slot[1]-1)
        if new_slot < self.slot:
            slots = slots[new_slot-1:self.slot-1]
            for slot in slots:
                update_slot(slot[0], slot[1]+1)
        update_slot(self.id, new_slot)

    def delete(self):
        slots = get_slots(self.list_id)[self.slot+1:]
        for slot in slots:
            update_slot(slot[0], slot[1] - 1)
        delete_habit(self.id)

    def get_habitTrackings(self) -> list[HabitTrackings]:
        trackings = []
        for rawTracking in get_habitTrackings_by_habit_id(self.id):
            trackings.append(HabitTrackings(rawTracking[0], rawTracking[1],
                                            datetime.strptime(rawTracking[2], "%Y-%m-%dT%H:%M:%S.%f")))
        return trackings

    def getStreak(self):
        streak = 0
        trackings = []

        for rawTracking in get_habitTrackings_by_habit_id(self.id):
            trackings.append(HabitTrackings(datetime.strptime(rawTracking[2], "%Y-%m-%d")))

        trackings.sort(reverse=True)
        if current_date == tracking[0]:
            streak += 1
            for habitdate in trackings[1:]:
                future_date = habitdate - relativedelta(day=1)
                if future_date - habitdate == 0-0-1:
                    streak + 1


            future_date = habitdate - relativedelta(day=1)

        for habitdate in trackings:
            current_date = date.today()
            if current_date == habitdate or current_date == habitdate - relativedelta(day=1):
                streak += 1

                future_date = habitdate - relativedelta(day=1)

        return streak



    def fill_statistics(self):
        count = 0
        self.checked = False
        for tracking in self.get_habitTrackings():
            if tracking.created_at.date() == datetime.today().date():
                self.checked = True

            # day
            if self.unit == 0:
                if tracking.created_at.date() == datetime.today().date():
                    count += 1
            # week
            elif self.unit == 1:
                if tracking.created_at.isocalendar()[1] == datetime.today().isocalendar()[1]:
                    count += 1
            # month
            elif self.unit == 2:
                if tracking.created_at.month == datetime.today().month:
                    count += 1
            # year
            elif self.unit == 3:
                if tracking.created_at.year == datetime.today().year:
                    count += 1

        self.percentage = int(count / self.times * 100)

    def to_json(self):
        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)

    def habit_list(self):
        from models.HabitList import HabitList
        raw_habitLists = get_habitList(self.list_id)
        return HabitList(raw_habitLists[0], raw_habitLists[1], raw_habitLists[2],
                         datetime.strptime(raw_habitLists[3], "%Y-%m-%dT%H:%M:%S.%f"),
                         datetime.strptime(raw_habitLists[4], "%Y-%m-%dT%H:%M:%S.%f")) \
        if raw_habitLists else None