import time
import traceback

from django.utils import timezone

from accounts.models import ItemPack
from sbc.public_methods import new_print, set_sbc_status, pin_events_creator, save_account_request, \
    sell_items, get_trade_pile
from accounts.web_login_utils import logout_login
from utils.ea_settings import fifa_23_address


class CheckHealthyRunner:
    def __init__(self, sbc_solver):
        from sbc.sbc_solver import SBCSolver
        self.sbc_solver: SBCSolver = sbc_solver
        self.fifa_account = self.sbc_solver.fifa_account
        self.sbc_worker = self.sbc_solver.sbc_worker


    def core(self, open_preview_gold_pack=False, sell_all_items=False, sell_club_items=False,
                              open_packs=False, create_club=False, order_active_squad=False):
        new_print(self.fifa_account, '#' * 10, 'account healthy 2 started', '#' * 10)
        new_print(self.fifa_account,
                  'works to do , open_preview_gold_pack : ', open_preview_gold_pack,
                  ' sell_all_items : ', sell_all_items,
                  ' sell_club_items : ', sell_club_items,
                  ' open_packs : ', open_packs,
                  ' create_club : ', create_club,
                  ' order_active_squad : ', order_active_squad
                  )
        self.sbc_worker.refresh_from_db()
        if not self.sbc_worker.status:
            set_sbc_status(self.sbc_worker, 'preparing ...')
            # self.sbc_worker.status = 'preparing ...'
            # self.sbc_worker.status_change_time = timezone.localtime()
            # self.sbc_worker.save(update_fields=['status', 'status_change_time'])
        login_result = logout_login(self.sbc_solver, self.sbc_worker, self.fifa_account, wait_after_error=10)
        new_print(self.fifa_account, 'account healthy login result : ', login_result)
        # if login_result == 'login failed':
        if login_result.get('status_bool') is False:
            raise Exception(login_result.get('reason'))
        try:
            self.sbc_solver.update_credit()
        except:
            new_print(self.fifa_account, 'sbc solver update credit error : ', traceback.format_exc())

        # if self.running_platform != 'console':
        #     problem_counter = 0
        #     while True:
        #         problem_counter += 1
        #         if problem_counter > 3:
        #             text = 'account have some issues %s' % self.username
        #             self.send_message(bot, 'critical', text)
        #             self.sbc_worker.error_description = "account problem"
        #             self.sbc_worker.has_error = 1
        #             self.sbc_worker.save()
        #             self.account_healthy_worker.error_description = "account problem"
        #             self.account_healthy_worker.has_error = 1
        #             self.account_healthy_worker.save()
        #
        #             self.handle_end_bot()
        #             time.sleep(50)
        #             return
        #         break
        if create_club:
            try:
                self.sbc_solver.create_club_web_app()
            except:
                new_print(self.fifa_account, 'create web club :', traceback.format_exc())

        try:
            # clim squad battle reward
            resp = self.sbc_solver.se.post(
                f'{fifa_23_address}/sqbt/user/prize',
                headers=self.sbc_solver.main_dic['header'])
            pin_events_creator(
                fifa_account=self.fifa_account,
                se=self.sbc_solver.se, persona_id=self.fifa_account.persona_id, nucleus_id=self.fifa_account.nucleus_id,
                source="Hub - Home", sid=self.sbc_solver.sid, counter=self.sbc_solver.get_pin_events_counter())
            save_account_request(
                fifa_account=self.fifa_account,
                link=f'{fifa_23_address}/sqbt/user/prize'
            )
            new_print(self.fifa_account, 'sqbt content = ', resp.text)
        except:
            new_print(self.fifa_account, 'error on battle squad clim : ', traceback.format_exc())

        while True:
            try:
                self.sbc_worker.refresh_from_db()
                if self.sbc_worker.must_done:
                    new_print(self.fifa_account, 'sbc worker ', self.sbc_worker,
                              ' must done_3 bot is done and must return something in main branch')
                    return 'its done'
                    # self.handle_end_bot()
                    # try:
                    #     self.handle_end_bot()
                    #     return 'handle end bot'
                    # except:
                    #     new_print(self.fifa_account, 'error 27 : ', traceback.format_exc())
                self.fifa_account.refresh_from_db()
                if not self.fifa_account.need_captcha:
                    sum_active_trades = 0
                    sum_starting_bids = 0
                    sum_unlisted_items = 0
                    active_trades = []
                    for retry in range(2):
                        self.sbc_solver.update_credit()

                        time.sleep(2)
                        self.sbc_solver.main_dic['bid_controller_count'] = 0
                        if open_packs:
                            # no need pin_events for store section
                            resp = self.sbc_solver.se.get(
                                f'{fifa_23_address}/store/purchaseGroup/cardpack?ppInfo=true',
                                headers=self.sbc_solver.main_dic['header'])
                            save_account_request(
                                fifa_account=self.sbc_solver.fifa_account,
                                link=f'{fifa_23_address}/store/purchaseGroup/cardpack?ppInfo=true',
                            )
                            json_resp = resp.json()
                            packs = json_resp['purchase']
                            set_sbc_status(self.sbc_worker, 'open packs', update_time=False)
                            for pack in packs:
                                if pack['coins'] == 0:
                                    new_print(self.fifa_account, 'pack id', pack['id'], 'will open')
                                    open_pack_resp = self.sbc_solver.open_pack(pack['id'])
                                    if pack['untradeable'] is False:
                                        pack_items = []
                                        try:
                                            pack_items = open_pack_resp.json()['itemList']
                                        except:
                                            new_print(self.fifa_account,
                                                      'open pack in sbc solver, pack id : ', pack['id'],
                                                      ' opened : ', open_pack_resp.text,
                                                      '\nerror: ', traceback.format_exc())
                                        pack_price = self.sbc_solver.calculate_pack_price(pack_items=pack_items)
                                    else:
                                        pack_price = 0
                                    ItemPack.objects.create(
                                        fifa_account=self.fifa_account,
                                        pack_id=pack['id'],
                                        open_price=0,
                                        pack_value=pack_price,
                                    )
                                    time.sleep(2)
                            self.sbc_solver.update_credit()
                        if sell_all_items:
                            if sell_club_items:
                                sell_items(self.sbc_solver, self.sbc_worker, self.fifa_account, sell_club_players=True)
                            else:
                                sell_items(self.sbc_solver, self.sbc_worker, self.fifa_account)
                        if open_preview_gold_pack:
                            self.sbc_solver.preview_and_open_good_gold_pack()
                        if order_active_squad:
                            self.sbc_solver.active_squad_handler()

                    # set_sub_log(self.sbc_worker, 'all sbc completed things.')
                    # self.all_sbc_completed = True
                    resp = get_trade_pile(self.fifa_account, self.sbc_solver.se, self.sbc_solver.main_dic, self.sbc_solver.server_key)
                    json_resp = resp.json()
                    trades = json_resp['auctionInfo']

                    for trade in trades:
                        if trade['tradeState'] == 'active':
                            sum_active_trades += 1
                            sum_starting_bids += trade['startingBid']
                            if (trade['itemData']['itemType'] == 'player' and
                                    self.sbc_solver.running_platform in ['console', 'console_web', 'console_web_pc']):
                                resp = self.sbc_solver.get_price_limit(trade['itemData']['id'])
                                js_resp = resp.json()
                                max_price = js_resp[0]['maxPrice']
                                # if str(trade['startingBid']) != str(min_price) and str(trade['buyNowPrice']) != max_price:
                                if str(trade['buyNowPrice']) != max_price:
                                    active_trades.append(trade)
                        elif trade['itemData']['untradeable'] is False:
                            sum_unlisted_items += 1
                    # self.sbc_worker.refresh_from_db()
                    # self.sbc_worker.sellable_players = sum_unlisted_items + sum_active_trades
                    # self.sbc_worker.save()
                    return


                else:
                    new_print(self.fifa_account, 'need captcha')
                    time.sleep(30)
                    set_sbc_status(self.sbc_worker, 'need captcha')
                    return 'need captcha'

            except:
                new_print(self.fifa_account, 'error 50 : ', traceback.format_exc())
                self.sbc_worker.refresh_from_db()
                if self.sbc_worker.must_done:
                    new_print(self.fifa_account, 'bot is done and must return something in main branch')
                    return 'its done'
                    # self.handle_end_bot()
                else:
                    self.sbc_solver.get_new_sid()
