class Card:
    def __init__(self):
        pass


class ATKCard(Card):
    def __init__(self, id, name):
        super(ATKCard, self).__init__()
        self.id = id
        self.name = name
        self.damage = 0
        self.text = ""
        self.texts = []
    def __repr__(self):
        #return str(self.id) + ". " + self.name + "(ATK)"
        return self.name + "(ATK)"
    def active(self, cur, ene):
        pass

class DEFCard(Card):
    def __init__(self, id, name):
        super(DEFCard, self).__init__()
        self.id = id
        self.name = name
    def __repr__(self):
        return self.name + "(DEF)"
    def passive(self):
        pass


class OtherCard(Card):
    def __init__(self, id, name):
        super(OtherCard, self).__init__()
        self.id = id
        self.name = name
    def __repr__(self):
        return self.name + "(Other)"
    def active(self):
        pass

class SPATKCard(ATKCard):
    def __init__(self, id, name):
        super(SPATKCard, self).__init__(id, name)
    def __repr__(self):
        return self.name + "(SP.ATK)"

class SPDEFCard(DEFCard):
    def __init__(self, id, name):
        super(SPDEFCard, self).__init__(id, name)
    def __repr__(self):
        return self.name + "(SP.DEF)"
# Abstract Class Definition

class Attack(ATKCard):
    def __init__(self):
        super(Attack, self).__init__(1 ,"攻擊")
        self.damage = 2
        self.text = "可悲垃圾{}打了{}{}"
    def active(self, cur, ene):
        self.texts = [cur.name, ene.name, self.damage]
        if not ene.inc_hp(0-self.damage):
            print(self.text.format(*self.texts))

class Defend(DEFCard):
    def __init__(self):
        super(Defend, self).__init__(2 ,"防禦")
    def passive(self, cur, ene, card):
        pass
        
class Heal(OtherCard):
    def __init__(self):
        super(Heal, self).__init__(3 ,"治癒")
    def active(self, cur, ene):
        cur.inc_hp(2)

class Supply(OtherCard):
    def __init__(self):
        super(Supply, self).__init__(4 ,"補給")
    def active(self, cur, ene):
        cur.draw(2)

class Rob(ATKCard):
    def __init__(self):
        super(Rob, self).__init__(5 ,"搶奪")
        self.text = "{}從{}那搶走了{}"
    def active(self, cur, ene):
        self.texts = [cur.name, ene.name]
        card = ene.drop()
        if not card:
            print("SAD, {}沒東西可搶".format(ene.name))
            return
        cur.get(card)
        self.texts.append(card)
        
        print(self.text.format(*self.texts))

class Suprise(ATKCard):
    def __init__(self):
        super(Suprise, self).__init__(6 ,"奇襲")
        self.damage = 1
        self.text = "{}攻擊{}{}，並使其掉落了一張{}"
    def active(self, cur, ene):
        card = ene.drop()
        self.texts = [cur.name, ene.name, self.damage]
        if not card:
            self.text = "{}攻擊{}{}"
        else:
            self.texts.append(card)
        ene.inc_hp(0-self.damage)
        print(self.text.format(*self.texts))

class Aware(DEFCard):
    def __init__(self):
        super(Aware, self).__init__(8 ,"傷心")
    def passive(self, cur, ene, card):
        cur.draw(1)
        print("好氣喔還抽了張卡片")

class Plan(OtherCard):
    def __init__(self):
        super(Plan, self).__init__(9 ,"妙策")
    def active(self, cur, ene):
        from random import sample
        from DeckGen import DeckGen
        l = DeckGen(sample(cur.deck, 3))
        for i, card in enumerate(l):
            print(i, ": ", card, sep="")
        while 1:
            try:
                choose = int(input())
                cur.get(l[choose])
                print("{}獲得{}".format(cur.name, l[choose]))
                cur.deck.remove(l[choose].id)
                break
            except:
                pass

class Sweep(ATKCard):
    def __init__(self):
        super(Sweep, self).__init__(10 ,"掃射的啦")
        self.damage = 0
        self.text = "可悲垃圾{}打了{}{}"
    def active(self, cur, ene):
        from random import randint
        self.damage = randint(0, 5)
        self.texts = [cur.name, ene.name, self.damage]
        ene.inc_hp(0-self.damage)
        print(self.text.format(*self.texts))

class Bless(OtherCard):
    def __init__(self):
        super(Bless, self).__init__(11 ,"加護")
    def active(self, cur, ene):
        cur.inc_hp(3)
        cur.poison = 0

class Poison(OtherCard):
    def __init__(self):
        super(Poison, self).__init__(12 ,"毒死你")
    def active(self, cur, ene):
        ene.poison += 1
        print("毒死你生效ㄌ")

class Counter(DEFCard):
    def __init__(self):
        super(Counter, self).__init__(14 ,"反打一波")
    def passive(self, cur, ene, card):
        print("反彈了傷害和效果:")
        """if isinstance(card, Rob):
            pass
        elif isinstance(card, Suprise):
            pass
        elif isinstance(card, Frenzy):
            cur.inc_hp(3)
            ene.inc_hp(-3)
            
        else:
            ene.inc_hp(0-card.damage)"""
        card.active(cur, ene)
        
class Frenzy(ATKCard):
    def __init__(self):
        super(Frenzy, self).__init__(15, "星爆氣流斬")
        self.damage = 3
        self.text = "可悲垃圾{}打了{}{}，並回復了3"
    def active(self, cur, ene):
        
        self.texts = [cur.name, ene.name, self.damage]
        ene.inc_hp(0-self.damage)
        cur.inc_hp(3)
        print(self.text.format(*self.texts))

class Guo1(SPDEFCard):
    def __init__(self):
        super(Guo1, self).__init__(101, "空間之鍊(門)")
    def passive(self, cur, ene, card):
        print("無效敵方能力並將1張{}加入手中".format(card))
        cur.get(card)

class Guo2(OtherCard):
    def __init__(self):
        super(Guo2, self).__init__(102, "空間之鍊(殼)")
    def active(self, cur, ene):
        print("下2個敵方的回合{}將不會受到傷害".format(cur.name))
        cur.guard = 2

class Guo3(SPATKCard):
    def __init__(self):
        super(Guo3, self).__init__(103, "空間之鍊(滅)")
        self.damage = 5
    def active(self, cur, ene):
        print("對敵方造成5點傷害並使敵方損失2張手牌")
        ene.drop(2)
        ene.inc_hp(0-self.damage)

class Rabbit1(SPATKCard):
    def __init__(self):
        super(Rabbit1, self).__init__(201, "科學無用論(高速砍擊)")
        self.damage = 3
    def active(self, cur, ene):
        ene.inc_hp(0-self.damage)
        print("優先於一切防禦能力的3點傷害攻擊")

class Rabbit2(OtherCard):
    def __init__(self):
        super(Rabbit2, self).__init__(202, "科學無用論(力量增幅)")
    def active(self, cur, ene):
        cur.boost = 3
        print("下3個回合對敵方造成的傷害+1")

class Rabbit3(SPATKCard):
    def __init__(self):
        super(Rabbit3, self).__init__(203, "科學無用論(終焉一擊)")
        self.damage = 5
    def active(self, cur, ene):
        ene.inc_hp(0-self.damage)
        print("優先於一切防禦能力的5點傷害攻擊")


"""
101 空間之鍊(門)x2，無效敵方能力並將1張相同卡牌加入手中 SPDEF
102 空間之鍊(殼)x2，下2個敵方的回合不會受到傷害 OTHER
103 空間之鍊(滅)x1，對敵方造成5點傷害並使敵方損失2張手牌 SPATK

201 科學無用論(高速砍擊)x3，優先於一切防禦能力的3點傷害攻擊 SPATK
202 科學無用論(力量增幅)x3，下3個回合對敵方造成的傷害+1 OTHER
203 科學無用論(終焉一擊)x1，優先於一切防禦能力的5點傷害攻擊 SPATK

"""