import difflib
import os
import time
import traceback

import cv2
import pytesseract
import unidecode
from PIL import Image
from django.db import close_old_connections
from django.utils import timezone

from accounts.models import AccountBoughtItem, ConsoleSpecialNames, PlayerCard, AccountSalablePlayerCard
from futplus.settings import BASE_DIR
from sbc import ARZBAZI_REPORT_TOPIC_DISCHARGE_ERROR_THREAD_MESSAGE_ID, ONE_WEEK_SECONDS, ONE_HOUR_SECONDS
from sbc.models import SBCTargetFilterClubMoves, SBCTargetFilterLeagueMoves, SBCTargetFilterNationMoves
from sbc.public_methods import new_print, telegram_send_photo, get_round_price, get_player_data_by_asset_id, \
    get_player_fifa_name_by_id, set_sbc_status, get_previous_price_grade, get_image_position, get_next_price_grade


class TransferListUtils:
    def __init__(self, public_moves_instance):
        from utils.public_moves import PublicMoves
        self.public_moves: PublicMoves = public_moves_instance
        self.fifa_account = self.public_moves.fifa_account
        self.sbc_worker = self.public_moves.sbc_worker
        self.ps4_buttons = self.public_moves.ps4_buttons


    def check_owner_contract(self, owner_count, contract_count):
        new_print(self.fifa_account, 'check owner and contract : ', owner_count, ' -- ', contract_count)
        self.ps4_buttons.r3()
        time.sleep(2)
        self.public_moves.get_screen_shot()
        owner_count_num, contract_count_num = 0, 0
        if self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_controls/player_data_play_styles.png'),
            'screen_shot_tmp.jpg'):
            # for iin in range(2):
            #     self.public_moves.get_screen_shot()
            #     if not self.public_moves.has_image(os.path.join(
            #         BASE_DIR,
            #         f'utils/{self.fifa_account.platform}_transfer_list_icons/player_data_icon.png'),
            #         'screen_shot_tmp.jpg'):
            #         self.ps4_buttons.l1()
            self.ps4_buttons.press_and_release_right_joystick(-32000, 0)
            time.sleep(1)
            self.public_moves.get_screen_shot()
            img = cv2.imread("screen_shot_tmp.jpg")
            crop_player_owner = img[440:470, 1190:1260]
            crop_player_owner = cv2.resize(crop_player_owner, None, fx=5, fy=5, interpolation=cv2.INTER_LANCZOS4)
            crop_player_owner = cv2.cvtColor(crop_player_owner, cv2.COLOR_BGR2GRAY)
            cv2.imwrite('card_owner_count_tmp.jpg', crop_player_owner)

            # img = cv2.imread("screen_shot_tmp.jpg")
            # crop_player_contract = img[490:515, 390:440]
            # crop_player_contract = cv2.cvtColor(crop_player_contract, cv2.COLOR_BGR2GRAY)
            # cv2.imwrite('card_contract_count_tmp.jpg', crop_player_contract)

            owner_count_text = self.public_moves.get_screen_text(
                'card_owner_count_tmp.jpg',
                config='--psm 7 --oem 3 -c tessedit_char_whitelist=0123456789',
                convert=True,
                convert_type=2
            )
            try:
                int_owner_count_text = int(owner_count_text)
            except:
                new_print(self.fifa_account, 'read owner contract mode 1 failed : ', traceback.format_exc(),
                          ' owner_count_text : ', owner_count_text)
                int_owner_count_text = 0
            if not owner_count_text or int_owner_count_text != int(owner_count):
                new_print(self.fifa_account, 'owner read not equal to count , ',
                          int_owner_count_text, ' -- ', owner_count)
                owner_count_text = self.public_moves.get_screen_text(
                    'card_owner_count_tmp.jpg',
                    config='--psm 8 --oem 3 -c tessedit_char_whitelist=0123456789',
                    convert=True,
                    convert_type=2
                )
            # contract_count_text = self.public_moves.get_screen_text(
            #     'card_contract_count_tmp.jpg',
            #     config='--psm 10 --oem 3 -c tessedit_char_whitelist=0123456789')
            # if not contract_count_text:
            #     contract_count_text = self.public_moves.get_screen_text(
            #         'card_contract_count_tmp.jpg',
            #         config='--psm 10 --oem 3 -c tessedit_char_whitelist=0123456789',
            #         convert=True,
            #         convert_type=2
            #     )
            try:
                owner_count_num = int(owner_count_text)
                # contract_count_num = int(contract_count_text)
            except:
                new_print(self.fifa_account, 'read owner contract error : ', traceback.format_exc(),
                          ' owner_count_text : ', owner_count_text)
                owner_count_num = 0
                # contract_count_num = 0
            new_print(self.fifa_account, 'read owner and contract result : ',
                      owner_count_num, ' - ', contract_count_num)
            if int(owner_count) != owner_count_num:
                new_print(self.fifa_account, f'error on discharge , owner count {owner_count} not equal text {owner_count_num} , press circle')
                # telegram_send_photo(self.fifa_account, os.path.join(BASE_DIR, 'screen_shot_tmp.jpg'),
                #                     caption=f'account {self.fifa_account} error on discharge , owner count {owner_count} not equal text {owner_count_num}',
                #                     message_thread_id=ARZBAZI_REPORT_TOPIC_DISCHARGE_ERROR_THREAD_MESSAGE_ID)
                self.ps4_buttons.circle()
                time.sleep(1)
                return {'status': 'failed', 'owner_count': owner_count_num, 'contract_count': contract_count_num}
            # contract not exsits anymore
            # if int(contract_count) != contract_count_num:
            #     self.ps4_buttons.circle()
            #     time.sleep(1)
            #     return {'status': 'failed', 'owner_count': owner_count_num, 'contract_count': contract_count_num}
            self.ps4_buttons.circle()
            time.sleep(1)
        self.public_moves.get_screen_shot()
        if self.public_moves.has_image(os.path.join(
                BASE_DIR,
                f'utils/{self.fifa_account.platform}_transfer_list_icons/player_data_icon.png'),
                'screen_shot_tmp.jpg'):
            new_print(self.fifa_account, 'check owner and contract but still in player data')
            self.ps4_buttons.circle()
            time.sleep(1)
        return {'status': 'success', 'owner_count': owner_count_num, 'contract_count': contract_count_num}

    def buy_healing(self, need_heals):
        new_print(self.fifa_account, 'need to buy heals, need = ', need_heals)
        self.public_moves.go_to_state('ultimate_team', 'search_consumables')
        time.sleep(0.5)
        self.ps4_buttons.r3()
        time.sleep(0.5)
        self.ps4_buttons.cross()
        time.sleep(0.5)
        self.ps4_buttons.right(sleep_after=0.5)
        self.ps4_buttons.right(sleep_after=0.5)
        # self.ps4_buttons.down(sleep_after=0.5)
        self.ps4_buttons.cross()
        time.sleep(0.5)
        self.ps4_buttons.down(sleep_after=0.5)
        self.ps4_buttons.cross()
        time.sleep(0.5)
        # todo : decrease price of healing
        search_res = self.public_moves.search_player_price(price=300, default_price=150)
        if search_res == 'can not find price':
            self.ps4_buttons.circle()
            time.sleep(1)
            self.ps4_buttons.circle()
            time.sleep(1)
            return self.buy_healing(need_heals)
        time.sleep(0.5)
        self.ps4_buttons.circle()
        time.sleep(0.5)
        self.ps4_buttons.up(sleep_after=0.5)
        for i in range(need_heals):
            bought = False
            for j in range(3):
                time.sleep(2)
                self.ps4_buttons.triangle()
                wait_result = self.public_moves.wait_for_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/transfer_market_no_search_result.png'),
                    special='live_search_results.png', wait_time=10)
                if wait_result is False:
                    return self.buy_healing(need_heals=need_heals - i)
                for nm in range(1):
                    self.ps4_buttons.r1()
                    time.sleep(.5)
                for k in range(3):

                    if self.buy_now():
                        # self.ps4_buttons.circle()
                        bought = True
                        AccountBoughtItem.objects.create(
                            fifa_account=self.fifa_account,
                            buy_price=200,
                            item_type='heal',
                            requested_worker='squad',
                        )
                        self.fifa_account.refresh_from_db()
                        self.fifa_account.credit -= 200
                        self.fifa_account.save(update_fields=['credit'])
                        break
                    self.ps4_buttons.right()
                self.ps4_buttons.circle()
                time.sleep(0.5)
                # todo : ea bug. every search need reset data. remove this after fix.
                break
                # if bought:
                #     break
            return self.buy_healing(need_heals=need_heals - 1)

    def buy_contract(self, need_contracts, manager=False):
        new_print(self.fifa_account, 'no contract need any more . this is bug.')
        return
        new_print(self.fifa_account, 'need to buy contracts, need = ', need_contracts)
        self.public_moves.go_to_state('ultimate_team', 'search_consumables')
        time.sleep(0.5)
        self.ps4_buttons.r3()
        time.sleep(0.5)
        if manager:
            self.ps4_buttons.cross()
            time.sleep(0.5)
            self.ps4_buttons.right()
            time.sleep(0.5)
            self.ps4_buttons.cross()
            time.sleep(0.5)
        self.ps4_buttons.right(sleep_after=0.5)
        self.ps4_buttons.cross()
        time.sleep(1)
        self.ps4_buttons.down(sleep_after=0.5)
        self.ps4_buttons.cross()
        self.ps4_buttons.left(sleep_after=0.5)
        self.ps4_buttons.down(sleep_after=0.5)
        self.ps4_buttons.cross()
        time.sleep(0.5)
        search_res = self.public_moves.search_player_price(price=200, default_price=150)
        if search_res == 'can not find price':
            self.ps4_buttons.circle()
            time.sleep(1)
            self.ps4_buttons.circle()
            time.sleep(1)
            return self.buy_contract(need_contracts, manager=manager)
        self.ps4_buttons.circle()
        time.sleep(0.5)
        self.ps4_buttons.up(sleep_after=0.5)
        for i in range(need_contracts):
            bought = False
            for j in range(3):
                time.sleep(2)
                self.ps4_buttons.triangle()
                wait_result = self.public_moves.wait_for_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/transfer_market_no_search_result.png'),
                    special='live_search_results.png', wait_time=10)
                if wait_result is False:
                    return self.buy_contract(need_contracts=need_contracts - i, manager=manager)
                next_page_press = 1 if manager else int(random.randint(3, 8))
                for nm in range(next_page_press):
                    self.ps4_buttons.r1()
                    time.sleep(.5)
                for k in range(3):

                    if self.buy_now():
                        # self.ps4_buttons.circle()
                        bought = True
                        AccountBoughtItem.objects.create(
                            fifa_account=self.fifa_account,
                            buy_price=200,
                            item_type='contract',
                            requested_worker='squad',
                        )
                        self.fifa_account.refresh_from_db()
                        self.fifa_account.credit -= 200
                        self.fifa_account.save(update_fields=['credit'])
                        break
                    self.ps4_buttons.right()
                self.ps4_buttons.circle()
                time.sleep(0.5)
                # todo : ea bug. every search need reset data. remove this after fix.
                break
                # if bought:
                #     break
            time.sleep(2)
            self.public_moves.get_screen_shot()
            if self.public_moves.has_image(
                    os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/live_search_results.png'),
                    'screen_shot_tmp.jpg') or self.public_moves.has_image(
                    os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/time_remaining.png'),
                    'screen_shot_tmp.jpg'):
                self.ps4_buttons.circle()
                time.sleep(1)
            # todo : ea bug. every search need reset data. remove this after fix.
            return self.buy_contract(need_contracts=need_contracts - 1, manager=manager)

    def buy_now(self, wait_for_list=False):
        new_print(self.fifa_account, 'buy now player , wait for list : ', wait_for_list)
        self.ps4_buttons.cross()
        time.sleep(0.5)
        if not self.public_moves.wait_for_image(
                os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/check_for_inside_bidding.png'),
                wait_time=2, special='no_wait_after_find'):
            return False
        self.public_moves.get_screen_shot()
        # if self.public_moves.has_image(os.path.join(BASE_DIR, 'utils/controls/no_credit_sign.png'),
        #                   'screen_shot_tmp.jpg'):
        #     new_print(self.fifa_account,'no credit ...')
        #     return False
        count = 0
        while True:
            if count > 5:
                telegram_send_photo(self.fifa_account, os.path.join(BASE_DIR, 'screen_shot_tmp.jpg'),
                                    caption=f'account {self.fifa_account} error on discharge , can not find buy sign',
                                    message_thread_id=ARZBAZI_REPORT_TOPIC_DISCHARGE_ERROR_THREAD_MESSAGE_ID)
                new_print(self.fifa_account, 'cant find buy now sign')
                return False
            self.public_moves.get_screen_shot()
            if not self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/buy_now_sign.png'),
                    'screen_shot_tmp.jpg'):
                self.ps4_buttons.down()
                time.sleep(1)
            else:
                break
            count += 1
        # time.sleep(0.5)
        self.ps4_buttons.cross()
        time.sleep(1)
        self.ps4_buttons.up()
        # time.sleep(0.5)
        self.ps4_buttons.cross()
        time.sleep(1)
        if self.public_moves.wait_for_image(os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/purchase_was_success.png'),
                               wait_time=7, special='check_failed'):
            new_print(self.fifa_account, 'buy item success')
            for ii in range(3):
                self.public_moves.get_screen_shot()
                if not self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/after_buy.png'),
                    'screen_shot_tmp.jpg'):
                    self.ps4_buttons.up()
                    new_print(self.fifa_account, 'press up to find assign now')
                    time.sleep(1)
            self.ps4_buttons.cross()
            time.sleep(2)
            if self.public_moves.wait_for_images([
                os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/after_buy_in_list.png'),
                os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/transfers_keep_items.png')
            ], wait_time=7):
                new_print(self.fifa_account, 'in new items list')
                # if start_price:
                #     new_print(self.fifa_account, 'after buy item. has start price.')
                #     for i in range(3):
                #         new_print(self.fifa_account, 'sell item press square')
                #         self.ps4_buttons.square()
                #         time.sleep(2)
                #         self.public_moves.get_screen_shot()
                #         time.sleep(.5)
                #         if not self.public_moves.has_image(os.path.join(
                #                 BASE_DIR,
                #                 f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_sign.png'),
                #                 'screen_shot_tmp.jpg'):
                #             self.ps4_buttons.cross()
                #             time.sleep(2)
                #         else:
                #             break
                #     if not self.list_on_transfer_market(
                #             start_price, buy_now_price, second=True,
                #             player_min_price=player_min_price,
                #             player_max_price=player_max_price,
                #             wait_for_list=wait_for_list):
                #         new_print(self.fifa_account, 'could not list item')
                #         return False
                # else:
                #     new_print(self.fifa_account, 'after buy item. have not start price.')
                #     self.public_moves.get_screen_shot()
                #
                #     if self.public_moves.has_image(os.path.join(
                #             BASE_DIR,
                #             f'utils/{self.fifa_account.platform}_controls/swap_with_duplicate.png'),
                #             'screen_shot_tmp.jpg'):
                #         new_print(self.fifa_account, 'find swap with duplicate.')
                #         self.ps4_buttons.cross()
                #         time.sleep(1)
                #         self.ps4_buttons.cross()
                #         time.sleep(1)
                #         self.ps4_buttons.press_and_release_right_joystick(128, 250)
                #         time.sleep(1)
                if not wait_for_list:
                    new_print(self.fifa_account, 'after buy item. have not wait for list.')
                    self.public_moves.get_screen_shot()

                    if self.public_moves.has_image(os.path.join(
                            BASE_DIR,
                            f'utils/{self.fifa_account.platform}_controls/swap_with_duplicate.png'),
                            'screen_shot_tmp.jpg'):
                        new_print(self.fifa_account, 'find swap with duplicate.')
                        self.ps4_buttons.cross()
                        time.sleep(1)
                        self.ps4_buttons.cross()
                        time.sleep(1)
                        self.ps4_buttons.press_and_release_right_joystick(128, 250)
                        time.sleep(1)

                    self.ps4_buttons.r2()
                time.sleep(2)
                return True
        return False

    def list_on_transfer_market(self, start_price, buy_now_price, list_with_default_values=False, second=False,
                                player_min_price=0, player_max_price=0, wait_for_list=False):
        # the second is list after buy . default is list on transfer list
        new_print(self.fifa_account, 'list item on transfer market : ', start_price, buy_now_price)
        if not second:
            self.ps4_buttons.cross()
        time.sleep(1)
        if not list_with_default_values:
            new_print(self.fifa_account, 'not list with default values 1 , the second : ', second)
            if not second:
                try:
                    self.set_price(start_price, second, player_min_price, bid_or_buy='bid')
                except Exception as err:
                    if err.__str__() == 'cant set price for this one error':
                        new_print(self.fifa_account, 'cant set price so set price with default')
                        return self.list_on_transfer_market(
                            start_price=start_price, buy_now_price=buy_now_price,
                            list_with_default_values=True, second=second,
                            player_min_price=player_min_price, wait_for_list=wait_for_list
                        )
                    else:
                        raise err
            else:
                count = 0
                while True:
                    count += 1
                    new_print(self.fifa_account, 'try to find start price')
                    if count == 10:
                        self.ps4_buttons.circle()
                    if count > 20:
                        return False
                    self.public_moves.get_screen_shot()
                    if self.public_moves.has_image(os.path.join(
                            BASE_DIR,
                            f'utils/{self.fifa_account.platform}_controls/start_price_active_second.png'),
                            # 'screen_shot_tmp.jpg') or self.public_moves.has_image(os.path.join(
                            # BASE_DIR,
                            # f'utils/{self.fifa_account.platform}_controls/start_price_active_second_2.png'),
                            'screen_shot_tmp.jpg', threshold=.8):
                        if self.set_price(start_price, second, player_min_price, bid_or_buy='bid'):
                            break
                    if self.public_moves.has_image(os.path.join(
                            BASE_DIR, f'utils/{self.fifa_account.platform}_controls/control_set_price_sign.png'),
                            'screen_shot_tmp.jpg', threshold=.8):
                        self.ps4_buttons.circle()
                        time.sleep(0.5)
                    self.ps4_buttons.down()
                    time.sleep(0.5)
        else:
            self.ps4_buttons.l2()
            time.sleep(1)
        self.ps4_buttons.down()
        time.sleep(.5)
        if not list_with_default_values:
            new_print(self.fifa_account, 'not list with default values 2 , the second : ', second)
            if not second:
                self.set_price(buy_now_price, second, get_next_price_grade(start_price), buy_now=True, bid_or_buy='buy')
            else:
                count = 0
                while True:
                    count += 1
                    new_print(self.fifa_account, 'try to find buy now price')
                    if count == 10:
                        self.ps4_buttons.circle()
                    if count > 20:
                        return False
                    self.public_moves.get_screen_shot()
                    if self.public_moves.has_image(os.path.join(
                            BASE_DIR,
                            f'utils/{self.fifa_account.platform}_controls/buy_now_price_active_second.png'),
                            # 'screen_shot_tmp.jpg') or self.public_moves.has_image(os.path.join(
                            # BASE_DIR,
                            # f'utils/{self.fifa_account.platform}_controls/buy_now_price_active_second_2.png'),
                            'screen_shot_tmp.jpg', threshold=.8):
                        if self.set_price(buy_now_price, second, get_next_price_grade(start_price),
                                          buy_now=True, bid_or_buy='buy'):
                            break
                    if self.public_moves.has_image(os.path.join(
                            BASE_DIR,
                            f'utils/{self.fifa_account.platform}_controls/control_set_price_sign.png'),
                            'screen_shot_tmp.jpg', threshold=.8):
                        self.ps4_buttons.circle()
                        time.sleep(0.5)
                    self.ps4_buttons.down()
                    time.sleep(0.5)
        else:
            self.ps4_buttons.r2()
            time.sleep(1)
        count = 0
        self.ps4_buttons.down()
        self.ps4_buttons.down()
        while True:
            new_print(self.fifa_account, 'try to find list on transfer the second')
            count += 1
            if count == 10:
                self.ps4_buttons.circle()
            if count > 20:
                return False
            self.public_moves.get_screen_shot()
            if self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_the_second.png'),
            #         'screen_shot_tmp.jpg'
            # ) or self.public_moves.has_image(os.path.join(
            #     BASE_DIR,
            #     f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_the_second_2.png'),
                'screen_shot_tmp.jpg', threshold=.8
            ) or self.public_moves.has_image(os.path.join(
                BASE_DIR,
                # todo : ps and xbox360 image added. add xboxs image
                f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_the_first.png'),
                'screen_shot_tmp.jpg'
            ):
                break
            if self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/control_set_price_sign.png'),
                    'screen_shot_tmp.jpg'):
                self.ps4_buttons.circle()
                time.sleep(0.5)
            self.ps4_buttons.down(sleep_after=.5)

        # if second:
        #     count = 0
        #     while True:
        #         new_print(self.fifa_account, 'try to find list on transfer the second')
        #         count += 1
        #         if count == 10:
        #             self.ps4_buttons.circle()
        #         if count > 20:
        #             return False
        #         self.public_moves.get_screen_shot()
        #         if self.public_moves.has_image(os.path.join(
        #                 BASE_DIR,
        #                 f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_the_second.png'),
        #                 'screen_shot_tmp.jpg'):
        #             break
        #         if self.public_moves.has_image(os.path.join(
        #                 BASE_DIR,
        #                 f'utils/{self.fifa_account.platform}_controls/control_set_price_sign.png'),
        #                 'screen_shot_tmp.jpg'):
        #             self.ps4_buttons.circle()
        #             time.sleep(0.5)
        #         self.ps4_buttons.down()
        #         time.sleep(0.5)
        # else:
        #     self.ps4_buttons.down()
        #     self.ps4_buttons.down()
        #     self.ps4_buttons.down()

        if not wait_for_list:
            time.sleep(1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.public_moves.wait_for_image(os.path.join(
                BASE_DIR,
                f'utils/{self.fifa_account.platform}_controls/item_transfer_sucess.png'))
            self.ps4_buttons.cross()
            # time.sleep(3)
        return True
        # todo :delete below and uncomment top
        # self.ps4_buttons.circle()
        # time.sleep(1)

    def set_price(self, price, second=False, main_default_number=0, buy_now=False, bid_or_buy='bid'):
        inside_set = False
        new_print(self.fifa_account, 'main_default_number = ', main_default_number, 'buy now = ', buy_now)
        if buy_now:
            self.ps4_buttons.l2()
        count = 0
        while True:
            if count > 20:
                new_print(self.fifa_account, 'cant set price for this one 4')
                self.ps4_buttons.circle()
                # self.public_moves.go_to_state('transfers', 'transfers')
                raise Exception('cant set price for this one error')

            try:
                count += 1
                self.public_moves.get_screen_shot()
                self.__get_start_price(second, bid_or_buy=bid_or_buy)
                if main_default_number:
                    default_number = str(main_default_number)
                else:
                    new_print(self.fifa_account, 'need to get price from picture')
                    try:
                        new_print(self.fifa_account, 'reading start price')
                        default_number = self.public_moves.get_screen_text('start_price_tmp.jpg', convert=True, convert_type=2)[
                                         :-1].replace(',', '').replace('.', '')
                        default_number = str(get_round_price(default_number))
                    except:
                        try:
                            new_print(self.fifa_account, 'reading start price step 2')
                            default_number = self.public_moves.get_screen_text(
                                'start_price_tmp.jpg',
                                config='--psm 10 --oem 3 -c tessedit_char_whitelist=0123456789',
                                convert=True, convert_type=2)[:-1].replace(',', '').replace('.', '')
                            default_number = str(get_round_price(default_number))
                        except:
                            return False
                if str(price) == default_number:
                    break
                if count % 5 == 0:
                    new_print(self.fifa_account, 'change default number to some thing else to pass the bug')
                    default_number = str(int(default_number) * 2)
                    # count = 0
                default_number = ((8 - len(default_number)) * '0') + default_number
                new_print(self.fifa_account, 'default number = ', default_number)
                if int(price) < 5000:
                    self.set_price_with_l_and_r(int(default_number), int(price))
                else:
                    inside_set = False
                    self.ps4_buttons.cross()
                    inside_set = True
                    self.search_player_select_price(price, default_number=default_number)
                    inside_set = False
                if (not second and int(price) < 100000) or main_default_number:
                    break
                time.sleep(0.5)
            except:
                new_print(self.fifa_account, 'set price error : ', traceback.format_exc())
                if inside_set:
                    self.ps4_buttons.cross()
                time.sleep(2)
        return True

    def __get_start_price(self, second, bid_or_buy='bid'):
        new_print(self.fifa_account, 'get start price. second is : ', second)
        # if second:
        #     start_price = get_image_position(
        #         os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/list_transfer_directions2.png'),
        #         'screen_shot_tmp.jpg')
        # else:
        #     start_price = get_image_position(
        #         os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/list_transfer_directions.png'),
        #         'screen_shot_tmp.jpg')
        # top_left = start_price.get('top_right')
        # start_price_width = start_price.get('width')
        # start_price_height = start_price.get('height')
        img = cv2.imread("screen_shot_tmp.jpg")
        if second:
            if bid_or_buy == 'bid':
                crop_player_name = img[360:390, 1340:1440]
            elif bid_or_buy == 'buy':
                crop_player_name = img[405:440, 1560:1740]
            # crop_player_name = img[top_left[1]:top_left[1] + start_price_height,
            #                    top_left[0]:top_left[0] + (start_price_width * 2)]
            # new_print(self.fifa_account, 'get start price crop codes 1 : ',
            #           [top_left[1], top_left[1] + start_price_height,
            #            top_left[0], top_left[0] + (start_price_width * 2)])

        else:
            if bid_or_buy == 'bid':
                crop_player_name = img[330:370, 1440:1650]
            elif bid_or_buy == 'buy':
                crop_player_name = img[400:440, 1440:1650]
            # crop_player_name = img[top_left[1]:top_left[1] + start_price_height,
            #                    top_left[0]:top_left[0] + (start_price_width * 3)]
            # new_print(self.fifa_account, 'get start price crop codes 2 : ',
            #           [top_left[1], top_left[1] + start_price_height,
            #            top_left[0], top_left[0] + (start_price_width * 3)])
        crop_player_name = cv2.cvtColor(crop_player_name, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('start_price_tmp.jpg', crop_player_name)

    # todo : in new development
    def search_player_set_filters(self, level=None, rarity_ids=None, position=None,
                                  nation=None, team=None, league=None, try_counter=0):
        if try_counter > 10:
            new_print(self.fifa_account, 'try more than 10 times. break')
            return 'failed'
        if level or rarity_ids:
            quality_name = f'{level or "bronze"}{rarity_ids or 0}'
            new_print(self.fifa_account, 'search player find quality 1 ', quality_name)
            if self.move_to_next_icon('quality') != 'success':
                new_print(self.fifa_account, 'not hovered quality')
                return self.search_player_set_filters(
                    level=level, rarity_ids=rarity_ids, position=position, nation=nation,
                                                      team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_quality(quality_name)
            time.sleep(2)
            if not self.check_selected_quality(quality_name):
                new_print(self.fifa_account, 'selected quality not fixed')
                return self.search_player_set_filters(
                    level=level, rarity_ids=rarity_ids, position=position, nation=nation,
                                                      team=team, league=league, try_counter=try_counter+1)
        if position:
            new_print(self.fifa_account, 'search player find position', position)
            if self.move_to_next_icon('position') != 'success':
                new_print(self.fifa_account, 'not hovered position')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=position, nation=nation,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_position(position)
            time.sleep(1)
        if nation:
            nation_moves = SBCTargetFilterNationMoves.objects.filter(nation=nation).first()
            if not nation_moves:
                new_print(self.fifa_account, 'nation not found')
                set_sbc_status(self.sbc_worker, 'nation not found')
                # self.sbc_worker.status = 'nation not found'
                # self.sbc_worker.status_change_time = timezone.localtime()
                time.sleep(100)
                return False
            new_print(self.fifa_account, 'search player find nation', nation)
            if self.move_to_next_icon('nation') != 'success':
                new_print(self.fifa_account, 'not hovered nation')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=nation,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_nation(nation_moves)
            time.sleep(2)

        if team:
            new_print(self.fifa_account, 'search player find club', team)
            team_moves = SBCTargetFilterClubMoves.objects.filter(team=team).first()
            if not team_moves:
                new_print(self.fifa_account, 'club not found')
                set_sbc_status(self.sbc_worker, 'club not found')
                time.sleep(100)
                return False
            league_moves = SBCTargetFilterLeagueMoves.objects.filter(league=league).first()
            if not league_moves:
                new_print(self.fifa_account, 'league not found')
                set_sbc_status(self.sbc_worker, 'league not found')
                time.sleep(100)
                return False
            if self.move_to_next_icon('league') != 'success':
                new_print(self.fifa_account, 'not hovered league')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=None,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_league(league_moves)
            time.sleep(1)
            if self.move_to_next_icon('club') != 'success':
                new_print(self.fifa_account, 'not hovered club')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=None,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_club(team_moves)
            time.sleep(2)
        elif league:
            new_print(self.fifa_account, 'search player find league', league)
            league_moves = SBCTargetFilterLeagueMoves.objects.filter(league=league).first()
            if not league_moves:
                new_print(self.fifa_account, 'league not found')
                set_sbc_status(self.sbc_worker, 'league not found')
                time.sleep(100)
                return False
            if self.move_to_next_icon('league') != 'success':
                new_print(self.fifa_account, 'not hovered league')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=None,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_league(league_moves)
            time.sleep(2)
        return 'success'

    def move_to_next_icon(self, next_icon_name, try_counter=0):
        current_position = self.what_search_icon_hovered()
        if not current_position or try_counter > 2:
            return 'missed way'
        movements = [['name', 'quality', 'position'],
                     ['pricing', 'nation', 'league', 'club']]
        need_movements = []
        if next_icon_name in movements[0] and current_position in movements[1]:
            need_movements.append(self.ps4_buttons.up)
        elif next_icon_name in movements[1] and current_position in movements[0]:
            need_movements.append(self.ps4_buttons.down)
        if current_position in movements[0]:
            current_move_index = movements[0].index(current_position)
        else:
            current_move_index = movements[1].index(current_position)

        if next_icon_name in movements[0]:
            next_move_index = movements[0].index(next_icon_name)
        else:
            next_move_index = movements[1].index(next_icon_name)

        if next_move_index > current_move_index:
            for nn in range(next_move_index - current_move_index):
                need_movements.append(self.ps4_buttons.right)
        else:
            for nn in range(current_move_index - next_move_index):
                need_movements.append(self.ps4_buttons.left)
        for item in need_movements:
            item(sleep_after=.5)
        if self.what_search_icon_hovered() == next_icon_name:
            return 'success'
        else:
            time.sleep(10)
            return self.move_to_next_icon(next_icon_name=next_icon_name, try_counter=try_counter+1)

    def what_search_icon_hovered(self):
        self.public_moves.get_screen_shot()
        if self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_search_player_icons/name_hover.png'),
            'screen_shot_tmp.jpg'):
            return 'name'

        elif self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_search_player_icons/quality_hover.png'),
            'screen_shot_tmp.jpg'):
            return 'quality'

        elif self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_search_player_icons/position_hover.png'),
            'screen_shot_tmp.jpg'):
            return 'position'

        elif self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_search_player_icons/country_hover.png'),
            'screen_shot_tmp.jpg'):
            return 'nation'

        elif self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_search_player_icons/league_hover.png'),
            'screen_shot_tmp.jpg'):
            return 'league'

        elif self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_search_player_icons/club_hover.png'),
            'screen_shot_tmp.jpg'):
            return 'club'

        elif self.public_moves.has_image(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_search_player_icons/pricing_hover.png'),
            'screen_shot_tmp.jpg'):
            return 'pricing'

    def find_player(self, player_name: str, player_rate: str, player_asset_id, counter=0, wait_for_fix_name=True,
                    player_special_name=None):
        new_print(self.fifa_account, 'find player , data : ', player_name, '--',
                  player_rate, '--', player_asset_id, '--', counter,
                  ' -- player_special_name ', player_special_name,
                  ' unicode name ', unidecode.unidecode((player_special_name or player_name or '').lower()))
        original_player_name = player_name
        check_special = ConsoleSpecialNames.objects.filter(player_name=player_name, player_rating=player_rate).first()
        if check_special and check_special.edited_name:
            player_name = check_special.edited_name
            new_print(self.fifa_account, 'find player , check special : ', player_name)
        try:
            if player_special_name and counter < 2:
                new_print(self.fifa_account, 'search player name , using special name , ',
                          player_name, ' -- ', player_special_name)
                status = self.search_player_enter_text(player_special_name)
            else:
                status = self.search_player_enter_text(player_name)
        except:
            if counter < 5:
                new_print(self.fifa_account, f'{counter + 1} time get error when see target.will try 1 more time')
                return False
            new_print(self.fifa_account, 'error on find player : ', traceback.format_exc())
            self.sbc_worker.refresh_from_db()
            old_status_1 = self.sbc_worker.status
            self.sbc_worker.status = 'player not found'
            self.sbc_worker.status_change_time = timezone.localtime()
            self.sbc_worker.save()
            special_name, name_created = ConsoleSpecialNames.objects.get_or_create(
                player_name=original_player_name, player_rating=player_rate)
            if name_created:
                player_card_item = PlayerCard.objects.exclude(rating=0).filter(asset_id=player_asset_id).order_by('rare').first()
                if player_card_item:
                    card_info = get_player_data_by_asset_id(player_asset_id=player_asset_id)
                    futbin_result = self.public_moves.sbc_solver_instance.get_player_price_from_futbin_web_app(
                        player_name=player_card_item.name,
                        player_rate=player_card_item.rating,
                        player_known_as=card_info[1],
                        player_rare=player_card_item.rare,
                        player_f=card_info[2], player_l=card_info[3],
                        player_asset_id=player_card_item.asset_id
                    )
                    special_name.edited_name = unidecode.unidecode(futbin_result.get('display_name'))
            else:
                special_name.edited_name = ''
            special_name.last_fifa_account = self.fifa_account
            special_name.last_time = timezone.localtime()
            special_name.save()
            for ii in range(50):
                time.sleep(5)
                special_name.refresh_from_db()
                if special_name.edited_name:
                    self.sbc_worker.status = old_status_1
                    self.sbc_worker.save()
                    self.ps4_buttons.circle()
                    time.sleep(0.5)
                    return False
                else:
                    self.ps4_buttons.right(sleep_after=1)
                    self.ps4_buttons.left()
                if ii >= 49:
                    return 'player name not found'

        compare_name = player_name
        if check_special:
            if check_special.compare_name:
                compare_name = check_special.compare_name
        player_name = compare_name

        screen_text = self.public_moves.get_screen_text()
        if screen_text.lower().find('no results were found') != -1 or self.public_moves.has_image(
                os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/player_search_not_found.png'),
                "screen_shot_tmp.jpg"
        ):
            new_print(self.fifa_account, 'in search player with price No results were found')
            return False

        if self.current_letter_pos[0] == 0:
            # new_print(self.fifa_account,'2 down press')
            self.ps4_buttons.down(sleep_after=.5)
            self.ps4_buttons.down(sleep_after=.5)
        else:
            # new_print(self.fifa_account,'1 down press')
            self.ps4_buttons.down(sleep_after=.5)
        # last_word_pos = self.public_moves.keyboard.get(player_name[-1].lower())
        # if last_word_pos:
        #     if last_word_pos[0] == 0:
        #         new_print(self.fifa_account,'2 down press')
        #         self.ps4_buttons.down()
        #         self.ps4_buttons.down()
        #     else:
        #         new_print(self.fifa_account,'1 down press')
        #         self.ps4_buttons.down()
        # else:
        #     new_print(self.fifa_account,'2 down press')
        #     self.ps4_buttons.down()
        #     self.ps4_buttons.down()

        # self.ps4_buttons.down()
        # self.ps4_buttons.down()
        player_name = self.fix_name_for_compare(player_name)
        if player_special_name:
            player_special_name = self.fix_name_for_compare(player_special_name)
        main_player_name = player_name
        first_time = True
        try_with_first_name = False

        players_list = []
        while True:
            new_player = self.get_players_position()
            new_player_name = new_player[0].replace('\x0c', '').strip().lower()
            new_player_name = self.remove_other_letters_except_latin(new_player_name)
            player_name_fix_i_problem = ''
            for n in new_player_name.split():
                if n:
                    if n[0] == 'i':
                        player_name_fix_i_problem += 'l' + n[1:] + ' '
                    else:
                        player_name_fix_i_problem += n + ' '
            new_player_name = player_name_fix_i_problem[:-1]

            new_player_rate = new_player[1].replace('\x0c', '').strip()
            if new_player_rate == '719' or new_player_rate == '793':
                new_player_rate = '79'
            new_print(self.fifa_account, 'player data =', player_name, ' -- ',
                      new_player_name, ' -- ', new_player_rate, ' -- ', player_rate,
                      '\nplayer data2 =', unidecode.unidecode(player_name.lower()), ' -- ',
                      unidecode.unidecode(new_player_name.lower()), ' -- ', int(new_player_rate or 0),
                      ' -- ', int(player_rate), ' len player name : ', len(player_name), ' -- ', len(new_player_name),
                      ' special name : ', player_special_name, ' -- ', len(player_special_name or ''))
            # new_print(self.fifa_account, 'player data2 =', unidecode.unidecode(player_name.lower()), ' -- ',
            #           unidecode.unidecode(new_player_name.lower()), ' -- ', int(new_player_rate),
            #           ' -- ', int(player_rate))
            if int(new_player_rate or 0) == int(player_rate) and len(player_name.strip()) == len(new_player_name.strip()):
                counter_2 = 0
                equal = 1
                while counter_2 < len(player_name):
                    if (player_name[counter_2] != new_player_name[counter_2]) and (player_name[counter_2] != '*'):
                        equal = 0
                        break
                    counter_2 += 1
                if equal:
                    self.ps4_buttons.cross()
                    return True
            elif (player_special_name and int(new_player_rate or 0) == int(player_rate) and
                  len(player_special_name.strip()) == len(new_player_name.strip())):
                counter_2 = 0
                equal = 1
                while counter_2 < len(player_special_name):
                    if (player_special_name[counter_2] != new_player_name[counter_2]) and (player_special_name[counter_2] != '*'):
                        equal = 0
                        break
                    counter_2 += 1
                if equal:
                    self.ps4_buttons.cross()
                    return True

            #     (unidecode.unidecode(player_name.lower()) in unidecode.unidecode(new_player_name.lower())
            # )) and int(new_player_rate) == int(player_rate):
            #     self.ps4_buttons.cross()
            #     return True
            ignore_this_one = False

            if new_player_name in players_list:
                self.public_moves.get_screen_shot()
                if (not try_with_first_name) and (
                        not self.public_moves.has_image(os.path.join(
                            BASE_DIR,
                            f'utils/{self.fifa_account.platform}_controls/just_one_search_result.png'),
                            "screen_shot_tmp.jpg")):
                    try_with_first_name = True
                    players_list = []
                    ignore_this_one = True
                    player_name = get_player_fifa_name_by_id(player_asset_id, need_first_name=True)
                    player_name = self.fix_name_for_compare(player_name)
                # elif first_time and status == 'complete name':
                #     first_time = False
                #     players_list = []
                #     self.ps4_buttons.circle()
                #     self.ps4_buttons.r2()
                #     ignore_this_one = True
                #     player_name = main_player_name
                else:
                    break

            if not ignore_this_one:
                players_list.append(new_player_name)
            self.ps4_buttons.down()
            time.sleep(1)

        self.public_moves.get_screen_shot()
        if self.public_moves.has_image(os.path.join(
                BASE_DIR,
                f'utils/{self.fifa_account.platform}_controls/just_one_search_result.png'),
                "screen_shot_tmp.jpg"):
            new_print(self.fifa_account, 'in searching name , just one result founded')
            try:
                searching_name = player_name
                if player_special_name and counter < 2:
                    searching_name = player_special_name
                counter_3 = 0
                not_match_count = 0
                while counter_3 < len(searching_name):
                    if (str(searching_name[counter_3]) not in str(new_player_name)) and (
                            str(searching_name[counter_3]) != '*'):
                        # equal = 0
                        # break
                        not_match_count += 1
                    counter_3 += 1
                if float(not_match_count) / len(searching_name) < 0.2:
                    new_print(self.fifa_account, 'I think its equal', searching_name, new_player_name)
                    self.ps4_buttons.cross()
                    return True
                else:
                    similarity_ratio = difflib.SequenceMatcher(None, searching_name.lower(), new_player_name.lower()).ratio() * 100
                    new_print(self.fifa_account, 'name is not equal ',
                              searching_name, ' -- ', counter_3, ' -- ', new_player_name,
                              f' similarity_ratio {similarity_ratio:.2f}%')
            except:
                new_print(self.fifa_account, 'error on find player : ', traceback.format_exc())

        if counter < 5:
            new_print(self.fifa_account, f'{counter + 1} time cant see the target.will try 1 more time')
            return False

        new_print(self.fifa_account, 'player not found ', original_player_name, ' - rate : ', player_rate)
        special_name, created = ConsoleSpecialNames.objects.get_or_create(
            player_name=original_player_name, player_rating=player_rate)
        special_name.edited_name = ''
        special_name.last_fifa_account = self.fifa_account
        special_name.last_time = timezone.localtime()
        special_name.save()
        self.sbc_worker.refresh_from_db()
        old_status = self.sbc_worker.status
        set_sbc_status(self.sbc_worker, 'player not found')
        if wait_for_fix_name is False:
            return 'player name not found'
        while True:
            time.sleep(5)
            special_name.refresh_from_db()
            if special_name.edited_name:
                self.sbc_worker.status = old_status
                self.sbc_worker.save()
                self.ps4_buttons.circle()
                time.sleep(0.5)
                return False
            else:
                self.ps4_buttons.right(sleep_after=1)
                self.ps4_buttons.left()
            # if ((player_name in new_player_name) or

    def search_player_enter_text(self, text: str):
        text = text.lower()
        english_text = unidecode.unidecode(text.lower())
        need_to_change_word = False
        for each_word in english_text.split():
            if each_word.find('-') != -1 or each_word.find("'") != -1:
                need_to_change_word = True
                new_print(self.fifa_account, 'need_to_change_word')
        if need_to_change_word:
            for each_word in english_text.split():
                if each_word.find('-') == -1 and each_word.find("'") == -1:
                    english_text = each_word

        self.public_moves.get_screen_shot()

        current_character = self.public_moves.keyboard.get(self.get_current_active_character() or 'a')
        count = 0
        for character in english_text:
            if count > 2:
                self.public_moves.get_screen_shot()
                if self.public_moves.has_image(os.path.join(
                        BASE_DIR,
                        f'utils/{self.fifa_account.platform}_controls/just_one_search_result.png'),
                        "screen_shot_tmp.jpg"):
                    return 'half name'
                if self.public_moves.has_image(os.path.join(
                        BASE_DIR,
                        f'utils/{self.fifa_account.platform}_controls/player_search_not_found.png'),
                        "screen_shot_tmp.jpg"):
                    return
            count += 1
            if character == ' ':
                self.ps4_buttons.r2()
                continue
            select_character = self.public_moves.keyboard.get(character)
            result_num = select_character[1] - current_character[1]
            if current_character[0] != select_character[0]:
                self.ps4_buttons.up()
            if result_num > 0:
                for i in range(result_num):
                    self.ps4_buttons.right()
            elif result_num < 0:
                for i in range(abs(result_num)):
                    self.ps4_buttons.left()
            self.ps4_buttons.cross()
            current_character = self.public_moves.keyboard.get(character)
            self.current_letter_pos = current_character
        return 'complete name'

    def get_current_active_character(self):
        keyboards_path = os.path.join(BASE_DIR, 'utils/keyboards/')
        keyboard_characters = os.listdir(keyboards_path)
        self.public_moves.get_screen_shot()
        for active_character in keyboard_characters:
            if self.public_moves.has_image(os.path.join(keyboards_path, active_character), 'screen_shot_tmp.jpg'):
                return active_character[0]


    def get_players_position(self):
        self.public_moves.get_screen_shot()

        # # top_left = get_image_position('utils/controls/player_name_icon.PNG', 'screen_shot_tmp.jpg').get('bottom_left')
        # cross = get_image_position(os.path.join(
        #     BASE_DIR,
        #     f'utils/{self.fifa_account.platform}_controls/cross_icon_search_player.png'),
        #     'screen_shot_tmp.jpg')
        # top_left = cross.get('top_right')
        # cross_button = cross.get('bottom_right')
        # cross_width = cross.get('width')
        # bottom_right = get_image_position(os.path.join(
        #     BASE_DIR,
        #     f'utils/{self.fifa_account.platform}_controls/cancel_deactive.png'),
        #     'screen_shot_tmp.jpg').get('top_right')
        # img = cv2.imread("screen_shot_tmp.jpg")
        # crop_player_name = img[top_left[1]:cross_button[1], top_left[0]:bottom_right[0] - (cross_width * 2)]
        # crop_player_rate = img[top_left[1]:cross_button[1], bottom_right[0] - (cross_width * 2):bottom_right[0]]

        # # crop_player_name = img[top_left[1]:cross_button[1], top_left[0]:bottom_right[0]]
        # # crop_player_name = img[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]]
        # # crop_player_name = cv2.cvtColor(crop_player_name, cv2.COLOR_BGR2GRAY)
        line = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_controls/line_icon_search_player.png'),
            'screen_shot_tmp.jpg')
        top_left = line.get('top_left')
        bottom_left = line.get('bottom_left')
        img = cv2.imread("screen_shot_tmp.jpg")
        crop_player_name = img[top_left[1]+15:bottom_left[1]-15, 560:1100]
        crop_player_rate = img[top_left[1]+15:bottom_left[1]-15, 1200:1300]
        crop_player_name = cv2.resize(crop_player_name, None, fx=5, fy=5, interpolation=cv2.INTER_LANCZOS4)
        crop_player_rate = cv2.resize(crop_player_rate, None, fx=5, fy=5, interpolation=cv2.INTER_LANCZOS4)
        cv2.imwrite('players_list_name_tmp.jpg', crop_player_name)
        cv2.imwrite('players_rate_tmp.jpg', crop_player_rate)
        player_name = self.public_moves.get_screen_text('players_list_name_tmp.jpg', convert=True)
        player_rate = self.public_moves.get_screen_text('players_rate_tmp.jpg',
                                           config='--psm 10 --oem 3 -c tessedit_char_whitelist=0123456789',
                                           convert=True)
        return (player_name, player_rate)

    def fix_name_for_compare(self, player_name):
        new_print(self.fifa_account, 'fix name for compare ', player_name)
        player_name = player_name.lower()
        player_name = self.remove_other_letters_except_latin(player_name)
        player_name_fix_i_problem = ''
        for n in player_name.split():
            if n:
                if n[0] == 'i':
                    player_name_fix_i_problem += 'l' + n[1:] + ' '
                else:
                    player_name_fix_i_problem += n + ' '
        player_name = player_name_fix_i_problem[:-1]
        return player_name

    def remove_other_letters_except_latin(self, word):
        changed_word = ''
        for p in word:
            if p not in 'abcdefghijklmnopqrstuvwxyz ':
                changed_word += '*'
            else:
                changed_word += p
        return changed_word

    def search_transfer_list_item(self, parent_instance, have_to_sell):
        new_print(self.fifa_account, 'searching transfer list items, selling items on console')
        close_old_connections()
        one_more_chance = 0
        for transfer_counter in range(150):
            new_print(self.fifa_account, 'transfer counter , ', transfer_counter)
            self.public_moves.get_screen_shot()
            if self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/compare_price_icon.png'),
                    'screen_shot_tmp.jpg') or self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/compare_price_icon_2.png'),
                    'screen_shot_tmp.jpg'):
                player_short_data_found = False
                price = [0, 0]
                last_item = None
                try:
                    image_card_info = self.__transfer_list_get_card_info(short_data=True)
                    player_items = AccountSalablePlayerCard.objects.filter(
                        fifa_account=self.fifa_account,
                        player_card__unicode_name__icontains=unidecode.unidecode(
                            image_card_info.get('player_name').lower())
                    )
                    if len(player_items) == 1:
                        last_item = player_items.last()
                        price = [last_item.buy_now_price, last_item.create_time.timestamp()]
                        new_print(self.fifa_account, 'find player price with card name 1: ', price,
                                  ' player name : ', last_item.player_card,
                                  ' player rating : ', last_item.player_card.rating,
                                  ' player rare : ', last_item.player_card.rare)
                        player_short_data_found = True
                    # else:
                    #     if len(player_items) > 1:
                    #         new_print(self.fifa_account, 'find two of one card', player_items)
                    #     else:
                    #         new_print(self.fifa_account,
                    #                   'can not find any card with this data in saved cards')
                    #     price = self.get_player_price_from_futbin(
                    #         image_card_info.get('player_name'),
                    #         image_card_info.get('player_rate'),
                    #         image_card_info.get('player_known_as'),
                    #         image_card_info.get('player_club')
                    #     )
                except Exception as error_3:
                    new_print(self.fifa_account, 'cant get short data , exception : ', traceback.format_exc())
                    if 'connection already closed' in str(error_3):
                        close_old_connections()
                if not player_short_data_found:
                    try:
                        image_card_info = self.__transfer_list_get_card_info()
                        new_print(self.fifa_account, 'item in transfer list : ', image_card_info)
                        if image_card_info:
                            self.ps4_buttons.circle()
                            time.sleep(1)
                            new_print(self.fifa_account, 'player name rate known as', image_card_info.get('player_name'),
                                      image_card_info.get('player_rate'), image_card_info.get('player_known_as'),
                                      image_card_info.get('player_club'))
                            # try:
                            #     player_rate = int(image_card_info.get('player_rate'))
                            # except:
                            #     new_print(self.fifa_account, 'can not read player rate : ', traceback.format_exc())
                            #     player_rate = 0
                            # if player_rate < 75:
                            #     price = [0, 0]
                            # else:
                            try:
                                player_items = AccountSalablePlayerCard.objects.filter(
                                    fifa_account=self.fifa_account,
                                    player_card__unicode_name__icontains=unidecode.unidecode(
                                        image_card_info.get('player_name').lower())
                                )
                                if len(player_items) == 1:
                                    last_item = player_items.last()
                                    price = [last_item.buy_now_price, last_item.create_time.timestamp()]
                                    new_print(self.fifa_account, 'find player price with card name : ', price)

                                else:
                                    if len(player_items) > 1:
                                        new_print(self.fifa_account, 'find two of one card', player_items)
                                    else:
                                        new_print(self.fifa_account,
                                                  'can not find any card with this data in saved cards')
                                    search_result = parent_instance.get_player_data_from_futbin_with_name(
                                        image_card_info.get('player_name'),
                                        image_card_info.get('player_rate'),
                                        image_card_info.get('player_known_as'),
                                        image_card_info.get('player_club')
                                    )
                                    price = [search_result.get('first_price') or 0,
                                             search_result.get('update_time') or 0]
                            except:
                                new_print(self.fifa_account, 'exception in get player price from futbin : ',
                                          traceback.format_exc())
                                # new_print(self.fifa_account, traceback.format_exc())
                                price = [0, 0]
                            new_print(self.fifa_account, 'price and update time', price[0], price[1])
                        else:
                            price = [0, 0]
                    except:
                        new_print(self.fifa_account, 'exception in processing player image data : ',
                                  traceback.format_exc())
                        # new_print(self.fifa_account, traceback.format_exc())
                        self.ps4_buttons.circle()
                        time.sleep(1.5)
                        price = [0, 0]
                if last_item and last_item.player_card and last_item.player_card.resource_id:
                    try:
                        player_cache_name = f'futbin_player_{str(last_item.player_card.resource_id)}'
                        futbin_data = parent_instance.players_log_cache.get(player_cache_name)
                        local_card_info = get_player_data_by_asset_id(player_asset_id=last_item.player_card.asset_id)
                        if futbin_data and futbin_data.get('local_time_stamp') > (
                                time.time() - ONE_HOUR_SECONDS):
                            new_print(
                                self.fifa_account,
                                'log 5, this item was selected from futbin less than one hour ago ',
                                ' , so use old data again : ', futbin_data)
                            futbin_result = futbin_data
                        else:
                            futbin_result = parent_instance.get_player_price_from_futbin_web_app(
                                local_card_info[0],
                                last_item.player_card.rating,
                                local_card_info[1],
                                player_club=last_item.player_card.team,
                                player_rare=last_item.player_card.rare,
                                player_f=local_card_info[2], player_l=local_card_info[3],
                                player_asset_id=last_item.player_card.asset_id
                            )
                            if futbin_result.get('update_time_stamp'):
                                parent_instance.players_log_cache.set(
                                    player_cache_name, futbin_result, timeout=ONE_WEEK_SECONDS)
                        if futbin_result.get('first_price'):
                            price = [futbin_result.get('first_price'), futbin_result.get('update_time_stamp')]
                    except:
                        new_print(self.fifa_account,
                                  'exception 2 in get player price from futbin : ',
                                  traceback.format_exc())
                if price[0] == '0':
                    price = [0, 0]
                if price[0]:
                    # todo : uncomment bellow after three month of fifa start. for start of fifa , increase card prices
                    # buy_now_price = get_previous_price_grade(int(price[0]))
                    buy_now_price = int(price[0])
                    if have_to_sell:
                        buy_now_price = get_previous_price_grade(buy_now_price)
                    new_print(self.fifa_account, 'buy now price', buy_now_price)
                    if not self.list_on_transfer_market(start_price=str(get_previous_price_grade(buy_now_price)),
                                                        buy_now_price=str(buy_now_price)):
                        self.public_moves.errors()
                        self.public_moves.go_to_state('ps4_main', 'transfer_list')
                else:
                    if not self.list_on_transfer_market(start_price=0,
                                                        buy_now_price=0,
                                                        list_with_default_values=True):
                        self.public_moves.errors()
                        self.public_moves.go_to_state('ps4_main', 'transfer_list')
                time.sleep(2)
                continue
            self.public_moves.get_screen_shot()
            self.get_transfer_list_cards_position()
            self.ps4_buttons.right()
            time.sleep(1)
            self.public_moves.get_screen_shot()
            if self.public_moves.has_image('transfer_list_cards_tmp.jpg', 'screen_shot_tmp.jpg', threshold=.99):
                if one_more_chance > 2:
                    new_print(self.fifa_account, 'end of list. no any cards found.')
                    break
                one_more_chance += 1
            else:
                one_more_chance = 0
        new_print(self.fifa_account, 'fifa account delete old cards')
        close_old_connections()
        deleted_count = AccountSalablePlayerCard.objects.filter(fifa_account=self.fifa_account).delete()
        new_print(self.fifa_account, 'account cards deleted : ', deleted_count)

    def __transfer_list_get_card_info(self, short_data=False):
        if short_data:
            self.public_moves.get_screen_shot()
            self.get_player_short_info_crop()
            player_name = self.public_moves.get_screen_text('player_short_name_crop_tmp.jpg')[:-1].strip()
            player_rate = self.public_moves.get_screen_text(
                'player_rate_crop2_tmp.jpg', config='--psm 7 --oem 3 -c tessedit_char_whitelist=0123456789',
                convert=True)[:-1].strip()
            # player_club = self.public_moves.get_screen_text('player_club_crop_tmp.png')[:-1].strip()
            # player_rate = player_rate_position.split()[0]

            player_just_rate = ''
            for p in player_rate:
                if p in '1234567890':
                    player_just_rate += p
            player_rate = player_just_rate

            return {
                'player_name': player_name.lower(),
                'player_known_as': '',
                'player_rate': player_rate,
            }
        self.ps4_buttons.r3()
        if self.public_moves.wait_for_image(os.path.join(
                BASE_DIR,
                f'utils/{self.fifa_account.platform}_controls/player_bio_sign.png'), wait_time=3,
                special='no_wait_after_find'):
            # [self.ps4_buttons.l1() for i in range(3)]
            for iiin in range(3):
                self.public_moves.get_screen_text()
                if self.public_moves.has_image(
                        os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/player_bio_sign.png'),
                        'screen_shot_tmp.jpg'):
                    new_print(self.fifa_account, 'find player bio')
                    break
            # self.ps4_buttons.press_and_release_right_joystick(0, 126)
            time.sleep(1)
            self.public_moves.get_screen_shot()
            self.__get_player_bio_info_crop()
            # self.ps4_buttons.r1()
            # time.sleep(1)
            # self.public_moves.get_screen_shot()
            # self.__get_player_detail_info_crop()
            player_name = self.public_moves.get_screen_text('player_name_crop_tmp.jpg')[:-1].strip()
            player_known_as = self.public_moves.get_screen_text('player_known_as_crop_tmp.jpg')[:-1].strip()
            # player_card_type = self.public_moves.get_screen_text('player_card_type_crop_tmp.jpg')[:-1].strip()
            # player_rate_position = self.public_moves.get_screen_text('player_rate_position_crop_tmp.jpg')[:-1].strip()
            player_rate = self.public_moves.get_screen_text(
                'player_rate_crop_tmp.jpg', config='--psm 10 --oem 3 -c tessedit_char_whitelist=0123456789',
                convert=True)[:-1].strip()
            # player_club = self.public_moves.get_screen_text('player_club_crop_tmp.png')[:-1].strip()
            # player_rate = player_rate_position.split()[0]

            player_just_rate = ''
            for p in player_rate:
                if p in '1234567890':
                    player_just_rate += p
            player_rate = player_just_rate
            # player_position = player_rate_position.split()[2]
            return {'player_name': player_name.lower(),
                    'player_known_as': player_known_as,
                    # 'player_card_type': player_card_type,
                    'player_rate': player_rate,
                    # 'player_position': player_position,
                    # 'player_club': player_club,
                    }
        else:
            return {}

    def get_player_short_info_crop(self):
        corners_left_top = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_transfer_list_icons/corners_left_top.png'),
            'screen_shot_tmp.jpg')
        corners_right_down = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_transfer_list_icons/corners_right_down.png'),
            'screen_shot_tmp.jpg')
        top_left = corners_left_top.get('bottom_left')
        name_width = corners_right_down.get('top_right')[0] - corners_left_top.get('bottom_left')[0]
        name_height = corners_right_down.get('top_right')[1] - corners_left_top.get('bottom_left')[1]
        screen_shot = cv2.imread("screen_shot_tmp.jpg")
        crop_player_card_pure = screen_shot[top_left[1]:top_left[1] + name_height,
                           top_left[0]:top_left[0] + name_width]
        crop_player_card = cv2.cvtColor(crop_player_card_pure, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('player_card_crop_tmp.jpg', crop_player_card)

        if self.fifa_account.platform in ['xboxs', 'xbox360']:
            crop_player_short_name_position = crop_player_card_pure[170:190, 20:200]
        else:
            new_print(self.fifa_account, 'cant read data')
            crop_player_short_name_position = crop_player_card_pure[190:220, 20:200] # fake data
        crop_player_short_name_position = cv2.cvtColor(crop_player_short_name_position, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('player_short_name_crop_tmp.jpg', crop_player_short_name_position)

        if self.fifa_account.platform in ['xboxs', 'xbox360']:
            crop_player_rate_position = crop_player_card_pure[20:50, 20:60]
        else:
            new_print(self.fifa_account, 'cant read data')
            crop_player_rate_position = crop_player_card_pure[20:60, 20:60] # fake data

        crop_player_rate_position = cv2.resize(crop_player_rate_position, None, fx=5, fy=5, interpolation=cv2.INTER_CUBIC)
        crop_player_rate_position = cv2.cvtColor(crop_player_rate_position, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('player_rate_crop2_tmp.jpg', crop_player_rate_position)
        return {'status_bool': True, 'status': 'success'}

    def __get_player_bio_info_crop(self):
        name_icon = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_transfer_list_icons/name_icon.png'),
            'screen_shot_tmp.jpg')
        top_left = name_icon.get('bottom_left')
        name_width = name_icon.get('width')
        name_height = name_icon.get('height')
        screen_shot = cv2.imread("screen_shot_tmp.jpg")
        crop_player_name = screen_shot[top_left[1]:top_left[1] + name_height,
                           top_left[0]:top_left[0] + (name_width * 6)]
        crop_player_name = cv2.cvtColor(crop_player_name, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('player_name_crop_tmp.jpg', crop_player_name)
        known_as_icon = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_transfer_list_icons/known_as_icon.png'),
            'screen_shot_tmp.jpg')
        top_left = known_as_icon.get('bottom_left')
        known_as_width = known_as_icon.get('width')
        known_as_height = known_as_icon.get('height')
        crop_player_known_as = screen_shot[top_left[1] - int(known_as_height * .1):top_left[1] + known_as_height,
                               top_left[0]:top_left[0] + int(known_as_width * 4)]
        crop_player_known_as = cv2.cvtColor(crop_player_known_as, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('player_known_as_crop_tmp.jpg', crop_player_known_as)
        # card_type = get_image_position(os.path.join(
        #     BASE_DIR,
        #     f'utils/{self.fifa_account.platform}_transfer_list_icons/week_foot_icon.png'),
        #     'screen_shot_tmp.jpg')
        # top_left = card_type.get('bottom_left')
        # card_type_width = card_type.get('width')
        # card_type_height = card_type.get('height')
        # crop_player_card_type = screen_shot[top_left[1] - (card_type_height * 2):top_left[1] + card_type_height,
        #                         top_left[0] - (card_type_width * 5):top_left[0]]
        # crop_player_card_type = cv2.cvtColor(crop_player_card_type, cv2.COLOR_BGR2GRAY)
        # cv2.imwrite('player_card_type_crop_tmp.jpg', crop_player_card_type)
        player_rate_position = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_transfer_list_icons/known_as_icon.png'),
            'screen_shot_tmp.jpg')
        # top_left = player_rate_position.get('top_left')
        # rate_position_width = player_rate_position.get('width')
        # rate_position_height = player_rate_position.get('height')
        # crop_player_rate_position = screen_shot[
        #                             top_left[1] - rate_position_height:top_left[1] + int(rate_position_height * 1.5),
        #                             top_left[0] - (rate_position_width * 2):top_left[0] - rate_position_width]
        # crop_player_rate_position = cv2.cvtColor(crop_player_rate_position, cv2.COLOR_BGR2GRAY)
        # cv2.imwrite('player_rate_position_crop_tmp.jpg', crop_player_rate_position)
        top_left = player_rate_position.get('top_left')
        rate_position_width = player_rate_position.get('width')
        rate_position_height = player_rate_position.get('height')
        if self.fifa_account.platform in ['xboxs', 'xbox360']:
            crop_player_rate_position = screen_shot[430:470, 240:290]
            # crop_player_rate_position = screen_shot[
            #                             top_left[1] - rate_position_height:
            #                             top_left[1] + int(rate_position_height * 1.6),
            #                             top_left[0] - int(rate_position_width * 2.3):
            #                             top_left[0] - int(rate_position_width * 1.8)
            #                             ]
        else:
            crop_player_rate_position = screen_shot[
                                        top_left[1] - rate_position_height:
                                        top_left[1] + int(rate_position_height * 1.5),
                                        top_left[0] - (rate_position_width * 2):top_left[0] - rate_position_width]

        crop_player_rate_position = cv2.cvtColor(crop_player_rate_position, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('player_rate_crop_tmp.jpg', crop_player_rate_position)

    def __get_player_detail_info_crop(self):
        club_icon = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_transfer_list_icons/club_icon.png'),
            'screen_shot_tmp.jpg')
        top_left = club_icon.get('bottom_left')
        club_width = club_icon.get('width')
        club_height = club_icon.get('height')
        screen_shot = cv2.imread("screen_shot_tmp.jpg")
        crop_player_club = screen_shot[top_left[1]:top_left[1] + club_height,
                           top_left[0]:top_left[0] + (club_width * 6)]
        crop_player_club = cv2.cvtColor(crop_player_club, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('player_club_crop_tmp.png', crop_player_club)

    def get_live_search_count(self, have_to=False):
        counter = 1
        for i in range(8):
            self.public_moves.get_screen_shot()
            if self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/next_page_icon.png'), 'screen_shot_tmp.jpg'):
                return 11
            elif not have_to and self.public_moves.has_image(os.path.join(
                    BASE_DIR,
                    f'utils/{self.fifa_account.platform}_controls/2_results.png'),
                    'screen_shot_tmp.jpg'):
                return 2
            elif not have_to and self.public_moves.has_image(
                    os.path.join(BASE_DIR, f'utils/{self.fifa_account.platform}_controls/time_remaining.png'),
                    'screen_shot_tmp.jpg'):
                try:
                    remain_time = self.get_remaining_time()
                    if remain_time and remain_time < 3400:
                        new_print(self.fifa_account, 'searching for player , remain time : ', remain_time)
                        return 5
                except:
                    pass
                return 3
            elif not have_to:
                return 1
            new_print(self.fifa_account, 'after check 2 page')
            for j in range(10):
                try:
                    self.__get_cards_position()
                except:
                    time.sleep(1)
                    self.public_moves.get_screen_shot()
                    new_print(self.fifa_account, 'more try for get cards position', j)
            new_print(self.fifa_account, 'after __get_cards_position')
            self.ps4_buttons.right()
            time.sleep(1)
            self.public_moves.get_screen_shot()
            if not self.public_moves.has_image('cards_position_tmp.jpg', 'screen_shot_tmp.jpg', threshold=.9):
                counter += 1
            else:
                self.public_moves.get_screen_shot('test_screen.jpg')
                new_print(self.fifa_account, 'end of cards')
                break
            new_print(self.fifa_account, 'after last staffs')
        return counter

    def __get_cards_position(self):
        live_search = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_controls/live_search_results.png'),
            'screen_shot_tmp.jpg')
        top_left = live_search.get('bottom_left')
        transfer_list_width = live_search.get('width')
        bottom_right = [int(top_left[0] + transfer_list_width * 0.8), int(top_left[1] + transfer_list_width * 3.5)]
        # bottom_right = get_image_position(os.path.join(BASE_DIR, 'utils/controls/compare_price_icon.png'),
        #                                        'screen_shot_tmp.jpg').get('top_right')
        img = cv2.imread("screen_shot_tmp.jpg")
        # crop_player_name = img[top_left[0]:bottom_right[0],
        #                    top_left[1]:bottom_right[1]]
        crop_player_name = img[260:600, 150:1850]
        crop_player_name = cv2.cvtColor(crop_player_name, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('cards_position_tmp.jpg', crop_player_name)

    def get_transfer_list_cards_position(self):
        # live_search = get_image_position(os.path.join(
        #     BASE_DIR,
        #     f'utils/{self.fifa_account.platform}_controls/transfer_list.png'),
        #     'screen_shot_tmp.jpg')
        # top_left = live_search.get('bottom_left')
        # transfer_list_width = live_search.get('width')
        # bottom_right = [int(top_left[0] + transfer_list_width * 1.2), int(top_left[1] + transfer_list_width * 4.3)]
        # bottom_right = get_image_position(os.path.join(BASE_DIR, 'utils/controls/compare_price_icon.png'),
        #                                        'screen_shot_tmp.jpg').get('top_right')
        img = cv2.imread("screen_shot_tmp.jpg")
        # crop_player_name = img[top_left[0]:bottom_right[0],
        #                    top_left[1]:bottom_right[1]]
        crop_player_name = img[260:600, 150:1850]
        crop_player_name = cv2.cvtColor(crop_player_name, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('transfer_list_cards_tmp.jpg', crop_player_name)

    # todo : in new development
    def search_player_set_filters(self, level=None, rarity_ids=None, position=None,
                                  nation=None, team=None, league=None, try_counter=0):
        if try_counter > 10:
            new_print(self.fifa_account, 'try more than 10 times. break')
            return 'failed'
        if level or rarity_ids:
            quality_name = f'{level or "bronze"}{rarity_ids or 0}'
            new_print(self.fifa_account, 'search player find quality 1 ', quality_name)
            if self.move_to_next_icon('quality') != 'success':
                new_print(self.fifa_account, 'not hovered quality')
                return self.search_player_set_filters(
                    level=level, rarity_ids=rarity_ids, position=position, nation=nation,
                                                      team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_quality(quality_name)
            time.sleep(2)
            if not self.check_selected_quality(quality_name):
                new_print(self.fifa_account, 'selected quality not fixed')
                return self.search_player_set_filters(
                    level=level, rarity_ids=rarity_ids, position=position, nation=nation,
                                                      team=team, league=league, try_counter=try_counter+1)
        if position:
            new_print(self.fifa_account, 'search player find position', position)
            if self.move_to_next_icon('position') != 'success':
                new_print(self.fifa_account, 'not hovered position')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=position, nation=nation,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_position(position)
            time.sleep(1)
        if nation:
            nation_moves = SBCTargetFilterNationMoves.objects.filter(nation=nation).first()
            if not nation_moves:
                new_print(self.fifa_account, 'nation not found')
                set_sbc_status(self.sbc_worker, 'nation not found')
                # self.sbc_worker.status = 'nation not found'
                # self.sbc_worker.status_change_time = timezone.localtime()
                time.sleep(100)
                return False
            new_print(self.fifa_account, 'search player find nation', nation)
            if self.move_to_next_icon('nation') != 'success':
                new_print(self.fifa_account, 'not hovered nation')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=nation,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_nation(nation_moves)
            time.sleep(2)

        if team:
            new_print(self.fifa_account, 'search player find club', team)
            team_moves = SBCTargetFilterClubMoves.objects.filter(team=team).first()
            if not team_moves:
                new_print(self.fifa_account, 'club not found')
                set_sbc_status(self.sbc_worker, 'club not found')
                time.sleep(100)
                return False
            league_moves = SBCTargetFilterLeagueMoves.objects.filter(league=league).first()
            if not league_moves:
                new_print(self.fifa_account, 'league not found')
                set_sbc_status(self.sbc_worker, 'league not found')
                time.sleep(100)
                return False
            if self.move_to_next_icon('league') != 'success':
                new_print(self.fifa_account, 'not hovered league')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=None,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_league(league_moves)
            time.sleep(1)
            if self.move_to_next_icon('club') != 'success':
                new_print(self.fifa_account, 'not hovered club')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=None,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_club(team_moves)
            time.sleep(2)
        elif league:
            new_print(self.fifa_account, 'search player find league', league)
            league_moves = SBCTargetFilterLeagueMoves.objects.filter(league=league).first()
            if not league_moves:
                new_print(self.fifa_account, 'league not found')
                set_sbc_status(self.sbc_worker, 'league not found')
                time.sleep(100)
                return False
            if self.move_to_next_icon('league') != 'success':
                new_print(self.fifa_account, 'not hovered league')
                return self.search_player_set_filters(
                    level=None, rarity_ids=None, position=None, nation=None,
                    team=team, league=league, try_counter=try_counter+1)
            self.ps4_buttons.cross()
            time.sleep(1)
            self.find_league(league_moves)
            time.sleep(2)
        return 'success'

    # todo : in new development
    def search_player_set_player_name(self, player_name, player_rate, player_asset_id, try_counter=0):
        if try_counter > 10:
            new_print(self.fifa_account, 'try more than 10 times. break')
            return 'failed'
        if self.move_to_next_icon('name') != 'success':
            new_print(self.fifa_account, 'not hovered name')
            return self.search_player_set_player_name(
                player_name, player_rate, player_asset_id, try_counter=try_counter + 1)
        counter = 0
        while True:
            new_print(self.fifa_account, 'search player find player 2', player_name, ' rate : ', player_rate)
            self.ps4_buttons.cross()
            time.sleep(1)
            if counter > 2:
                card_info = get_player_data_by_asset_id(player_asset_id=player_asset_id)
                if card_info[4]:
                    player_rate = card_info[4]
                new_print(self.fifa_account,
                          f'can not find player {counter} time so change player rate to {player_rate}')
            if self.find_player(player_name, player_rate, player_asset_id,
                                                    counter=counter) is True:
                return 'success'
                # break
            counter += 1
            # self.ps4_buttons.circle()
            # time.sleep(0.5)
            self.ps4_buttons.circle()
            time.sleep(2)

    # todo : in new development
    def check_selected_filter_text(self, filter_name: str, compare_text):
        filter_name_positions = {
            # [ Y start: Y end, X start : X end]
            'quality': [520, 550, 600, 900],
            'position': [520, 550, 1030, 1300],
            'nation': [830, 860, 600, 900],
            'league': [830, 860, 1030, 1300],
            'team': [830, 860, 1440, 1730],
        }
        img_positions = filter_name_positions.get(filter_name)
        img = cv2.imread("screen_shot_tmp.jpg")
        print('img positions : ', img_positions)
        crop_filter_text = img[img_positions[0]:img_positions[1], img_positions[2]: img_positions[3]]
        crop_filter_text = cv2.cvtColor(crop_filter_text, cv2.COLOR_BGR2GRAY)
        # cv2.imwrite('cropped_selected_filter_text_tmp.jpg', crop_filter_text)
        # new_img = cv2.imread("screen_shot_tmp.jpg")
        crop_filter_text = cv2.resize(crop_filter_text, None, fx=1.2, fy=1.2, interpolation=cv2.INTER_LANCZOS4)
        # new_img = cv2.cvtColor(new_img, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('new_img_tmp.jpg', crop_filter_text)
        print('ok')
        print(pytesseract.image_to_string(Image.open('new_img_tmp.jpg'), lang='eng'))

    def find_quality(self, quality):
        qualities_dict = {
            'any': [0, 0], 'bronze0': [0, 1], '0': [0, 1], 'silver0': [0, 2],
            'gold0': [1, 0], 'bronze1': [1, 1], '1': [1, 1], 'silver1': [1, 2],
            'gold1': [2, 0], 'gold3': [2, 2],
            '134': [4, 0], 'bronze134': [4, 0],
            '111': [6, 0], 'bronze111': [6, 0],
            '65': [1, 1, 0, 2], 'bronze65': [1, 1, 0, 2],
            # '30': [5, 0], 'bronze30': [5, 0],
            '30': [2, 1, 0, 1], 'bronze30': [2, 1, 0, 1],
            '161': [0, 1, 0, 2], 'bronze161': [0, 1, 0, 2],
            '11': [1, 0, 0, 2], 'bronze11': [1, 0, 0, 2],
            '5': [0, 4, 0, 2], 'bronze5': [0, 4, 0, 2],
            '36': [0, 0, 5, 0], 'bronze36': [0, 0, 5, 0],
            '71': [1, 1, 2, 0], 'bronze71': [1, 1, 2, 0],
        }
        self.move_per_list(qualities_dict.get(quality))
        self.ps4_buttons.cross()

    def find_position(self, position):
        positions_dict = {
            'GK': [1, 1], 'RWB': [1, 2],
            'RB': [2, 0], 'CB': [2, 1], 'LB': [2, 2],
            'LWB': [3, 0], 'CDM': [3, 1], 'RM': [3, 2],
            'CM': [4, 0], 'LM': [4, 1], 'CAM': [4, 2],
            'CF': [5, 0], 'RW': [5, 1], 'ST': [5, 2],
            'LW': [6, 0]
        }
        self.move_per_list(positions_dict.get(position))
        self.ps4_buttons.cross()

    def find_nation(self, nation: SBCTargetFilterNationMoves):
        # data_dict = console_nation_moves
        # for nm in range(data_dict.get(nation)[2]):
        #     self.ps4_buttons.r1()
        #     time.sleep(.5)
        # self.move_per_list(data_dict.get(nation))
        self.move_per_list([nation.move_down, nation.move_right, nation.move_r1])
        self.ps4_buttons.cross()

    def find_league(self, league: SBCTargetFilterLeagueMoves):
        # data_dict = league_console_moves
        # self.move_per_list(data_dict.get(league))
        self.move_per_list([league.move_down, league.move_right, league.move_r1])
        self.ps4_buttons.cross()

    def find_club(self, club: SBCTargetFilterClubMoves):
        # for nm in range(club.move_r1):
        #     self.ps4_buttons.r1()
        #     time.sleep(.5)
        self.move_per_list([club.move_down, club.move_right, club.move_r1])
        self.ps4_buttons.cross()

    def move_per_list(self, movement: list):
        if len(movement) > 2:
            for r1 in range(movement[2]):
                self.ps4_buttons.r1()
                time.sleep(.5)
        if len(movement) > 3:
            for l1 in range(movement[3]):
                self.ps4_buttons.l1()
                time.sleep(.5)
        for y in range(movement[0]):
            self.ps4_buttons.down(sleep_after=.3)
        for x in range(movement[1]):
            self.ps4_buttons.right(sleep_after=.3)

    def check_selected_quality(self, quality):
        self.public_moves.get_screen_shot()
        qualities_dict = {
            'any': 'any', 'bronze0': 'bronze_common', '0': 'bronze_common', 'silver0': 'silver_common',
            'gold0': 'gold_common', 'bronze1': 'bronze_rare', '1': 'bronze_rare', 'silver1': 'silver_rare',
            'gold1': 'gold_rare', 'gold3': 'gold_team_of_the_week', 'position_modifier': 'position_modifier',
            '134': 'fantasy_fut', 'bronze134': 'fantasy_fut',
            '111': 'fantasy_fc', 'bronze111': 'fantasy_fc',
            '65': 'team_of_the_season_moment', 'bronze65': 'team_of_the_season_moment',
            '11': 'team_of_the_season', 'bronze11': 'team_of_the_season',
            '30': 'fut_birthday', 'bronze30': 'fut_birthday',
            '161': 'shapeshifters', 'bronze161': 'shapeshifters',
            '5': 'team_of_the_year', 'bronze5': 'team_of_the_year',
            '36': 'live_team_of_the_season', 'bronze36': 'live_team_of_the_season',
            '71': 'future_stars', 'bronze71': 'future_stars',
        }
        if self.public_moves.has_image(os.path.join(
                BASE_DIR,
                f'utils/{self.fifa_account.platform}_qualities/{qualities_dict.get(quality, "any")}.png'),
                "screen_shot_tmp.jpg"):
            return True
        return False

    def search_player_select_price(self, number, default_number='00000150'):
        number_text = ((8 - len(str(number))) * '0') + str(number)
        current_place = 0
        new_print(self.fifa_account, 'numbers , selecting = ', number_text, ' current = ', default_number)
        for number_character in number_text:
            for num in range(8 - current_place - len(number_text)):
                self.ps4_buttons.right()
                current_place += 1
            number_character_2 = int(number_character) - int(default_number[current_place])
            # new_print(self.fifa_account,'number_character_2', number_character_2)
            if number_character_2 > 0:
                for i in range(number_character_2):
                    self.ps4_buttons.up()
            else:
                for i in range(abs(number_character_2)):
                    self.ps4_buttons.down()
            number_text = number_text[1:]
        self.ps4_buttons.cross()

    def get_price_difference_level(self, price_1, price_2):
        count = 0
        if price_1 > price_2:
            while price_1 != price_2:
                price_1 = get_previous_price_grade(price_1)
                count -= 1
        else:
            while price_1 != price_2:
                price_1 = get_next_price_grade(price_1)
                count += 1
        # new_print(self.fifa_account, 'get price diff level : ', count)
        return count

    def set_price_with_l_and_r(self, default_price, price, use_r1_l1=True):
        while default_price != price:
            next_grade = default_price
            for i in range(10):
                next_grade = get_next_price_grade(next_grade)
            ten_pre_grade = default_price
            for i in range(10):
                ten_pre_grade = get_previous_price_grade(ten_pre_grade)
            if default_price < price < next_grade or default_price > price > ten_pre_grade:
                diff_with_default = self.get_price_difference_level(price, default_price)
                diff_with_next = self.get_price_difference_level(price, next_grade)
                new_print(self.fifa_account,
                          'diff_with_default = ', diff_with_default, 'diff_with_next =', diff_with_next,
                          ' default price : ', default_price, ' price : ', price)
                diff = diff_with_default
                if abs(diff_with_default) > abs(diff_with_next):
                    if use_r1_l1:
                        self.ps4_buttons.r1()
                    else:
                        for nnn in range(10):
                            self.ps4_buttons.right()
                    diff = diff_with_next
                for i in range(abs(diff)):
                    if diff < 0:
                        self.ps4_buttons.right()
                    else:
                        self.ps4_buttons.left()
                default_price = price
            elif default_price > price and ten_pre_grade >= price:
                if use_r1_l1:
                    self.ps4_buttons.l1()
                else:
                    for nnn in range(10):
                        self.ps4_buttons.left()
                default_price = ten_pre_grade
            else:
                if use_r1_l1:
                    self.ps4_buttons.r1()
                else:
                    for nnn in range(10):
                        self.ps4_buttons.right()
                default_price = next_grade

    def get_remaining_time(self):
        self.public_moves.get_screen_shot()
        time_remaining_pic = get_image_position(os.path.join(
            BASE_DIR,
            f'utils/{self.fifa_account.platform}_controls/time_remaining.png'),
            'screen_shot_tmp.jpg')
        top_left = time_remaining_pic.get('top_right')
        time_remaining_pic_width = time_remaining_pic.get('width')
        bottom_right = [int(top_left[0] + time_remaining_pic_width * 2.2),
                        int(top_left[1] + time_remaining_pic.get('height'))]
        # bottom_right = get_image_position(os.path.join(BASE_DIR, 'utils/controls/compare_price_icon.png'),
        #                                        'screen_shot_tmp.jpg').get('top_right')
        # print('top_left = ',top_left)
        # print('bottom_right = ',bottom_right)
        img = cv2.imread("screen_shot_tmp.jpg")
        crop_player_name = img[top_left[1]:bottom_right[1],
                           top_left[0] + int(time_remaining_pic_width):bottom_right[0]]
        crop_player_name = cv2.cvtColor(crop_player_name, cv2.COLOR_BGR2GRAY)
        cv2.imwrite('time_remaining_tmp.jpg', crop_player_name)
        remaining_time = self.public_moves.get_screen_text(
            'time_remaining_tmp.jpg', config='--psm 10 --oem 3')[:-1].strip()
        remaining_time_splited = remaining_time.split()
        seconds = 0
        if len(remaining_time_splited) == 4 or len(remaining_time_splited) == 2:
            if remaining_time_splited[1] == 'Secs':
                secs = int(remaining_time_splited[0])
                if secs > 59:
                    secs = 59
                seconds += secs
            elif remaining_time_splited[1] == 'Mins':
                secs2 = int(remaining_time_splited[0])
                if secs2 > 59:
                    secs2 = 59
                seconds += secs2 * 60
            elif remaining_time_splited[1] == 'Hours':
                seconds += int(remaining_time_splited[0]) * 3600
            elif remaining_time_splited[1] == 'Days':
                seconds += int(remaining_time_splited[0]) * 3600 * 24
            else:
                seconds += int(remaining_time_splited[0]) * 3600
            if len(remaining_time_splited) == 4:
                if remaining_time_splited[3] == 'Secs':
                    secs_1 = int(remaining_time_splited[2])
                    if secs_1 > 59:
                        secs_1 = 59
                    seconds += secs_1
                elif remaining_time_splited[3] == 'Mins':
                    secs_2 = int(remaining_time_splited[2])
                    if secs_2 > 59:
                        secs_2 = 59
                    seconds += secs_2 * 60
                elif remaining_time_splited[3] == 'Hours':
                    seconds += int(remaining_time_splited[2]) * 3600
                elif remaining_time_splited[3] == 'Days':
                    seconds += int(remaining_time_splited[2]) * 3600 * 24
        else:
            new_print(self.fifa_account, 'remain time is not fixed format : ', remaining_time)
            return False
        # new_print(self.fifa_account, 'remianing time : ', remaining_time)
        return seconds