import random
from otree.api import (
    models,
    widgets,
    BaseConstants,
    BaseSubsession,
    BaseGroup,
    BasePlayer,
    Currency as c,
    currency_range,
)


class Constants(BaseConstants):
    name_in_url = 'blackjack'
    players_per_group = None
    num_rounds = 5

    instructions_template = 'blackjack/instructions.html'
    coin_template = 'blackjack/coin_rules.html'



class Subsession(BaseSubsession):
    pass

class Group(BaseGroup):
    pass

class Player(BasePlayer):
    player_stock = models.IntegerField(initial=150)
    player_first = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    player_second = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    player_sum = models.IntegerField()
    player_coin = models.IntegerField(initial=0, min=1, max=10)
    more_card = models.BooleanField(initial=0, choices=[0, 1])
    newcard1 = models.IntegerField(min=1, max=10)
    newcard2 = models.IntegerField(min=1, max=10)
    newcard3 = models.IntegerField(min=1, max=10)
    newcard4 = models.IntegerField(min=1, max=10)
    newcard5 = models.IntegerField(min=1, max=10)
    newcard6 = models.IntegerField(min=1, max=10)
    player_result1 = models.IntegerField(min=player_sum)
    player_result2 = models.IntegerField(min=player_result1)
    player_result3 = models.IntegerField(min=player_result2)
    player_result4 = models.IntegerField(min=player_result3)
    player_result5 = models.IntegerField(min=player_result4)
    player_result6 = models.IntegerField(min=player_result5)
    player_result7 = models.IntegerField(min=player_result6)
    computer_first = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    computer_second = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    computer_newcard1 = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    computer_newcard2 = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    computer_newcard3 = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    computer_newcard4 = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    computer_newcard5 = models.IntegerField(initial=random.randint(1, 10), min=1, max=10)
    computer_sum = models.IntegerField(min=2, max=24)
    result = models.StringField(initial='結果')
    coin_result = models.IntegerField(min=0, max=300)

    def computer_card(self):
        self.computer_first = random.randint(1, 10)
        self.computer_second = random.randint(1, 10)
        self.computer_sum = self.computer_first + self.computer_second
        while self.computer_sum < 15:  
            self.computer_newcard1 = random.randint(1,10)
            self.computer_sum += self.computer_newcard1
            if self.computer_sum >= 15:
                break
            self.computer_newcard2 = random.randint(1,10)
            self.computer_sum += self.computer_newcard2
            if self.computer_sum >= 15:
                break
            self.computer_newcard3 = random.randint(1,10)
            self.computer_sum += self.computer_newcard3
            if self.computer_sum >= 15:
                break
            self.computer_newcard4 = random.randint(1,10)
            self.computer_sum += self.computer_newcard4
            if self.computer_sum >= 15:
                break
            self.computer_newcard5 = random.randint(1,10)
            self.computer_sum += self.computer_newcard5
            if self.computer_sum >= 15:
                break
        return self.computer_sum

    def player_card(self):
        self.player_sum = self.player_first + self.player_second

    def player_more_card(self):
        self.player_result1 = self.player_sum
        return self.player_result1

    def more_card_action1(self):
        if self.more_card == 1:
            self.newcard1 = random.randint(1, 10)
            self.player_result2 = self.player_result1 + self.newcard1
            return self.player_result2

    def more_card_action2(self):
        if self.more_card == 1:
            self.newcard2 = random.randint(1, 10)
            self.player_result3 = self.player_result2 + self.newcard2
            return self.player_result3

    def more_card_action3(self):
        if self.more_card == 1:
            self.newcard3 = random.randint(1, 10)
            self.player_result4 = self.player_result3 + self.newcard3
            return self.player_result4

    def more_card_action4(self):
        if self.more_card == 1:
            self.newcard4 = random.randint(1, 10)
            self.player_result5 = self.player_result4 + self.newcard4
            return self.player_result5

    def more_card_action5(self):
        if self.more_card == 1:
            self.newcard5 = random.randint(1, 10)
            self.player_result6 = self.player_result5 + self.newcard5
            return self.player_result6

    def more_card_action6(self):
        if self.more_card == 1:
            self.newcard6 = random.randint(1, 10)
            self.player_result7 = self.player_result6 + self.newcard6
            return self.player_result7
    
    def judge(self):
        self.player_stock -= self.player_coin
        return self.player_stock
        
    def judge1(self):
        # 双方がバースト
        if self.player_more_card() > 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        # pはバースト、（cはバーストしてない）
        elif self.player_more_card() > 20 and self.computer_card() <= 20:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        # pはバーストしてない、cはバースト
        elif self.player_more_card() <= 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.player_more_card() == self.computer_card():
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        elif self.player_more_card() > self.computer_card():
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.player_more_card() < self.computer_card():
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        else:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

    def judge2(self):
        # 双方がバースト
        if self.more_card_action1() > 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        # pはバースト、（cはバーストしてない）
        elif self.more_card_action1() > 20 and self.computer_card() <= 20:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        # pはバーストしてない、cはバースト
        elif self.more_card_action1() <= 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action1() == self.computer_card():
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        elif self.more_card_action1() > self.computer_card():
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action1() < self.computer_card():
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        else:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

    def judge3(self):
        # 双方がバースト
        if self.more_card_action2() > 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        # pはバースト、（cはバーストしてない）
        elif self.more_card_action2() > 20 and self.computer_card() <= 20:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        # pはバーストしてない、cはバースト
        elif self.more_card_action2() <= 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action2() == self.computer_card():
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        elif self.more_card_action2() > self.computer_card():
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action2() < self.computer_card():
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        else:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

    def judge4(self):
        # 双方がバースト
        if self.more_card_action3() > 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        # pはバースト、（cはバーストしてない）
        elif self.more_card_action3() > 20 and self.computer_card() <= 20:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        # pはバーストしてない、cはバースト
        elif self.more_card_action3() <= 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action3() == self.computer_card():
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        elif self.more_card_action3() > self.computer_card():
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action3() < self.computer_card():
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        else:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

    def judge5(self):
        # 双方がバースト
        if self.more_card_action4() > 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        # pはバースト、（cはバーストしてない）
        elif self.more_card_action4() > 20 and self.computer_card() <= 20:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        # pはバーストしてない、cはバースト
        elif self.more_card_action4() <= 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action4() == self.computer_card():
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        elif self.more_card_action4() > self.computer_card():
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action4() < self.computer_card():
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        else:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

    def judge6(self):
        # 双方がバースト
        if self.more_card_action5() > 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        # pはバースト、（cはバーストしてない）
        elif self.more_card_action5() > 20 and self.computer_card() <= 20:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        # pはバーストしてない、cはバースト
        elif self.more_card_action5() <= 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action5() == self.computer_card():
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        elif self.more_card_action5() > self.computer_card():
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action5() < self.computer_card():
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        else:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

    def judge7(self):
        # 双方がバースト
        if self.more_card_action6() > 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        # pはバースト、（cはバーストしてない）
        elif self.more_card_action6() > 20 and self.computer_card() <= 20:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        # pはバーストしてない、cはバースト
        elif self.more_card_action6() <= 20 and self.computer_card() > 20:
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action6() == self.computer_card():
            self.player_stock += self.player_coin
            return '引き分け', self.player_stock

        elif self.more_card_action6() > self.computer_card():
            self.player_stock += self.player_coin*2
            return '勝ち', self.player_stock

        elif self.more_card_action6() < self.computer_card():
            self.player_stock == self.player_stock
            return '負け', self.player_stock

        else:
            self.player_stock == self.player_stock
            return '負け', self.player_stock

    def vs_result(self):
        self.result = self.judge1()[0]
        return self.result

    def stock_result(self):
        self.coin_result = self.judge1()[1]
        return self.coin_result