from datetime import date, timedelta, datetime
import random
import eventlet
# MODULES
from modules.data.config import read as config_read
from modules.data.database import connect as db_connect
from modules.handler import outgoing
from modules.track.logging import log

# MODULES

class timestamp():
    def __init__(self):
        self.time_limit = float(config_read("posts", "PostTimeLimit")) * 60
        self.db = db_connect()
        self.db.create(self)

    @property
    def start(self):
        value = self.get_date_timestamp()
        self._start = value
        return self._start
    @start.setter
    def start(self, value):
        value = self.get_date_timestamp()
        self._start = value

    @property
    def end(self):
        value = self.get_date_timestamp(day_mod=1) - 1
        self._end = value
        return self._end
    @end.setter
    def end(self, value):
        value = self.get_date_timestamp(day_mod=1) - 1
        self._end = value

    @property
    def now(self):
        value = self.get_timestamp()
        self._now = value
        return value
    @now.setter
    def now(self, value):
        value = self.get_timestamp()
        self._now = value

    @property
    def post_slot_start(self):
        value = self.get_slot()['start']
        self._post_slot_start = value
        return self._post_slot_start
    @post_slot_start.setter
    def post_slot_start(self, value):
        self._post_slot_start = self._post_slot_start

    @property
    def post_slot_end(self):
        value = self.get_slot()['end']
        self._post_slot_end = value
        return self._post_slot_end
    @post_slot_end.setter
    def post_slot_end(self, value):
        self._post_slot_end = self._post_slot_end

    @property
    def date(self):
        date = str(datetime.now().date())
        self._date = date
        return self._date
    @date.setter
    def date(self, value):
        self._date = value

    def get_date_timestamp(self, year_mod=0, month_mod=0, day_mod=0, *args, **kwargs):
        modifier = [year_mod, month_mod, day_mod]

        now_mod = (datetime.now()+timedelta(days=day_mod))
        date = (str(now_mod.date()).replace("-0", "-")).split("-")
        date = [int(string) for string in date]

        timestamp = datetime(date[0], date[1], date[2]).timestamp()

        return timestamp

    def get_timestamp(self):
        now = (float(datetime.now().timestamp()))
        return now
    
    def generate_slot(self, data=None):
        for i in range(2):
            if i == 0:
                date = str(datetime.now().date())
                start = self.get_date_timestamp()
            else:
                now_mod = (datetime.now()+timedelta(days=1))
                date = (str(now_mod.date()))
                start = self.get_date_timestamp(0, 0, 1)

            self.cur.execute("SELECT date FROM time_slots WHERE date=?", (date,))
            if not self.cur.fetchone():
                log("INFO", f"Generating time slot for {date}")

                day_start = start + int(config_read("posts", "DayStart")) * 60 * 60
                day_end = start + int(config_read("posts", "DayStart")) * 60 * 60
                slot_start = random.randint(day_start, day_end)
                slot_end = slot_start + self.time_limit
                self.cur.execute("INSERT INTO time_slots (date, start, end) VALUES (?, ?, ?)", (date, slot_start, slot_end))
                self.db.commit()

    def get_slot(self):
        info = None

        date = str(datetime.now().date())
        self.cur.execute("SELECT start, end FROM time_slots WHERE date=?", (date,))
        rez = self.cur.fetchone()
        if rez:
            info = {'start':rez[0], 'end':rez[1]}
        return info

    def is_valid_time(self):
        if (self.now < self.post_slot_end) and (self.now >= self.post_slot_start):
            return True
        return False