User

import enums
import asyncio

import helpers
import keyboards
from scenary import main as scenary_main
import re
from dal import db, models
from dal.User_info import User_info
from dal.Scenary import Scenary
from dal.RefererPayment import RefererPayment
from dal.Prognoz import Prognoz
from datetime import datetime, timedelta
import requests
import json
from dal.ChatHistory import ChatHistory
from natal import routes as routes_natal
from chat import routes as routes_chat


class User:

    def __init__(self, user_id):
        self.new_refer_coins = 2
        self.status = enums.user_status.new_user
        self._model = models.Users()
        self.active_scenary = None
        self.user_info = None

        info = asyncio.run(db.get_user(user_id))
        if info is not None:
            self._model = info._data[0]
            self.status = enums.user_status.user

            self.user_info = User_info(self._model)  # убрать после рефакторинга language_code и user_name
            if self._model.scenary_id != 0:
                self.active_scenary = Scenary(self._model)

        if self.subscription_date != None:
            if datetime.now() > self.subscription_date:
                asyncio.run(self.get_subscription_transactions())

    @property
    def id(self):
        return self._model.id

    @property
    def scenary_id(self):
        return self._model.scenary_id

    @property
    def user_tg_id(self):
        return self._model.user_tg_id

    @property
    def chat_id(self):
        return self._model.chat_id

    @property
    def balance(self):
        return str(self._model.balance)

    @property
    def referer_id(self):
        return self._model.referer_id

    @property
    def add_data(self):
        return self.active_scenary.data

    @property
    def is_solvent(self):
        return self._model.is_solvent

    @property
    def is_banned(self):
        return self._model.is_banned

    @property
    def last_step_handler(self):
        return self._model.last_step_handler

    @property
    def subscription_date(self):
        return self._model.subscription_date

    @property
    def last_update(self):
        return self._model.last_update

    @property
    def partner_referer_link(self):
        return self._model.partner_referer_link

    @property
    def is_confirm_user(self):
        return self.status == enums.user_status.user

    @property
    def last_anoncement_id(self):
        return self._model.last_anoncement_id


    @property
    def is_subscribe(self):
        return self.subscription_date != None and self.subscription_date > datetime.now()

    @property
    def has_natal_calc_data(self):
        return self.user_info is not None \
               and self.user_info.name is not None \
               and self.user_info.birthday is not None \
               and self.user_info.gender is not None \
               and self.user_info.town is not None \
               and self.user_info.lat is not None \
               and self.user_info.lng is not None \
               and self.user_info.tz_info is not None

    @property
    def has_get_self_data(self):
        return self.has_natal_calc_data is True and \
               self.user_info.horoscope is not None \
               and self.user_info.aspects is not None

    @property
    def has_prognoz_data(self):
        return self.has_get_self_data is True \
               and self.add_data is not None \
               and self.add_data.transits is not None \
               and self.add_data.date is not None \
               and self.add_data.transits_aspects is not None

    @property
    def has_people_data(self):
        return self.add_data is not None \
               and self.add_data.name is not None \
               and self.add_data.birthday is not None \
               and self.add_data.gender is not None \
               and self.add_data.horoscope is not None \
               and self.add_data.aspects is not None

    @property
    def has_compatibility_data(self):
        return self.has_get_self_data is True \
               and self.add_data is not None \
               and self.add_data.couple_natal is not None \
               and self.add_data.couple_aspects is not None \
               and self.add_data.name is not None


    @last_anoncement_id.setter
    def last_anoncement_id(self,value):
        self._model.last_anoncement_id=value
        asyncio.run(db.update_user(self._model))


    async def add_balance(self, count):
        self._model.balance = self._model.balance + count
        await db.update_user(self._model)

    async def remove_balance(self, count):
        if not self.is_subscribe:
            self._model.balance = self._model.balance + count
            if self._model.balance < 0:
                self._model.balance = 0
                helpers.logs("remove_balance: у пользователя возник отрицательный баланс:" + "\n" + str(self.id))
            await db.update_user(self._model)
            if self.active_scenary is not None:
                 await self.active_scenary.set_spent_kosmik(count)

    def set_is_banned(self, status=True):
        self._model.is_banned = status
        asyncio.run(db.update_user(self._model))

    async def set_is_solvent(self, status=True):
        self._model.is_solvent = status
        await db.update_user(self._model)

    async def update_subscription_date(self):
        if self._model.subscription_date is not None:
            self._model.subscription_date = self._model.subscription_date + timedelta(days=31) + timedelta(hours=12)
        else:
            self._model.subscription_date = datetime.now() + timedelta(days=31) + timedelta(hours=12)
        await db.update_user(self._model)

    async def get_subscription_transactions(self):
        param = {'accountId': str(self.user_tg_id)}

        resp = requests.post("https://api.cloudpayments.ru/subscriptions/find",
                             auth=('pk_80920c858d1b89c850f7d4736b3fe', '92a561695b2167ad6169f9d2a4d48f1c'), data=param)
        if resp is not None:
            dictData = json.loads(resp.text)
            has_active_subscribe = False
            for item in dictData['Model']:
                if item['Status'] == 'Active':
                    next_date = datetime.fromisoformat(item['NextTransactionDateIso'])
                    if self.subscription_date is None or next_date > self.subscription_date:
                        self._model.subscription_date = next_date + timedelta(days=1)
                        await db.update_user(self._model)
                        return
                    has_active_subscribe = True
            if has_active_subscribe is False:
                self._model.subscription_date = None
                await db.update_user(self._model)


    # метод получения информации есть ли пропущеные данные регистрации
    def has_no_reg_data(self):
        return self.user_info.name is None or self.user_info.birthday is None or self.user_info.town is None or self.user_info.town == ""

    def new_user(self, bot, chat_id, user_tg_id, user_name, language_code, link):
        self._model.chat_id = chat_id
        self._model.user_tg_id = user_tg_id

        result = asyncio.run(db.insert_user(self._model))
        self._model = result._data[0]

        self.user_info = User_info(self._model, user_name, language_code, True)

        self.status = enums.user_status.user
        self.checkReferal(bot, link)

    def checkReferal(self, bot, link):
        if " " in link:
            try:
                lk = re.sub(r"[^а-яА-Яa-zA-Z0-9 ]", "", link.split()[1])
                if lk.isdigit():
                    referrer_candidate = User(int(lk))
                    if referrer_candidate.is_confirm_user:
                        self._model.referer_id = int(lk)
                        asyncio.run(referrer_candidate.add_balance(
                            self.new_refer_coins))  # обновляем количество койнов у реферала
                        helpers.bot_message_send_chat_id(referrer_candidate,
                                                         scenary_main.get_referal_text(referrer_candidate.balance,
                                                                                       self.new_refer_coins),
                                                         keyboards.menu())
                else:
                    self._model.referer_link = lk
                asyncio.run(db.update_user(self._model))

            except ValueError:
                pass

    def close_chat_history(self):
        asyncio.run(db.close_chat_history(self._model))
        self.active_scenary.is_closed = True  # close() Заменен на is_closed = True

    async def update_chat_history(self, question, answer, chat_type):
        history_record = ChatHistory(self.id, question, answer, chat_type)
        await history_record.insert()

    async def get_chat_history(self):
        return await db.get_user_chat_history(self._model)

    def set_new_scenary(self, type: enums.scenary):
        if self._model.scenary_id is not None and self._model.scenary_id != 0 and self.active_scenary != None:
            self.close_scenary()
        asyncio.run(db.close_chat_history(self._model))
        new_scenary = Scenary(self._model)
        self._model.scenary_id = new_scenary.insert(user_id=self.id, type=type)
        asyncio.run(db.update_user(self._model))
        self.active_scenary = Scenary(self._model)

    def close_scenary(self):
        self.active_scenary.is_closed = True # close() Заменен на is_closed = True
        self._model.scenary_id = 0
        asyncio.run(db.update_user(self._model))
        self.active_scenary = None

    def pay_partner(self, summ):
        if self._model.referer_link is not None:
            referer_id = asyncio.run(db.get_partner_id(self._model.referer_link))
            if referer_id is not None:
                payment = RefererPayment(referer_id._data[0], self.id, summ * 0.3)
                payment.insert()

    def set_last_step_handler(self, comand):
        if self._model.last_step_handler != comand:
            self._model.last_step_handler = comand
            asyncio.run(db.update_user_last_step_handler(self._model))

    def set_subscription_date(self, subscription_date):
        self._model.subscription_date = subscription_date
        asyncio.run(db.update_user(self._model))

    def calc_daily_prognoz(self):
        self.active_scenary = Scenary(self._model,False)
        self.active_scenary.scenary_type = enums.scenary.daily_prognoz
        self.active_scenary.data=Prognoz(self.id)
        if asyncio.run(routes_natal.natal_chart_prognoz(self)):
            return asyncio.run(routes_chat.get_daily_prognoz(self, "natal_result"))
        else:
            return False
    def get_all_towns(self):
        result=asyncio.run(db.get_user_scenary_prognoz_towns(self.id))
        if result is None or len(result)==0:
            return [(0, self.user_info.town)]
        result.sort(reverse=True)
        return result