package at.reisinger;

import at.reisinger.server.helper.EnumHelper;
import com.fasterxml.jackson.annotation.*;

/**
 * Object einer at.reisinger.Card
 */
@JsonAutoDetect
public class Card {
    @JsonProperty
    private String name;
    @JsonProperty
    private double damage;
    @JsonProperty
    private ElementTyp elementTyp;
    @JsonProperty
    private CardType cardType;
    @JsonProperty
    private boolean locked;

    /**
     * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften
     * @param name Name der at.reisinger.Card
     * @param damage Damage den die at.reisinger.Card macht
     * @param elementTyp ElementType der at.reisinger.Card
     * @param cardType at.reisinger.CardType der at.reisinger.Card
     */
    public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) {
        this.name = name;
        this.damage = damage;
        this.elementTyp = elementTyp;
        this.cardType = cardType;
    }

    /**
     * Erstellt eine neue Card mit, anhand des cardNamen werden der ElementType und der CardType automatisch bestimmt
     * @param name Name der Card (ID)
     * @param elementCardTyp ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
     *                       Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
     * @param damage Damage der Card
     */
    @JsonCreator
    public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
        CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
        ElementTyp tmpElement = null;
        if(tmpCard == null){
            tmpCard = CardType.UNDEF;
        }

        //Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen
        if (tmpCard.name().toLowerCase().equals("dragon")){
            tmpElement = ElementTyp.FIRE;
        }else if (tmpCard.name().toLowerCase().equals("ork")){
            tmpElement = ElementTyp.REGULAR;
        }
        else if (tmpCard.name().toLowerCase().equals("wizzard")){
            tmpElement = ElementTyp.REGULAR;
        }else if (tmpCard.name().toLowerCase().equals("kraken")){
            tmpElement = ElementTyp.WATER;
        }else if (tmpCard.name().toLowerCase().equals("elf")){
            tmpElement = ElementTyp.REGULAR;
        }else if (tmpCard.name().toLowerCase().equals("goblin")){
            tmpElement = ElementTyp.REGULAR;
        }else if (tmpCard.name().toLowerCase().equals("troll")){
            tmpElement = ElementTyp.REGULAR;
        }else if (tmpCard.name().toLowerCase().equals("knight")){
            tmpElement = ElementTyp.REGULAR;
        }else if (tmpCard.name().toLowerCase().equals("fireelves")){
            tmpElement = ElementTyp.FIRE;
        }

        if(tmpElement == null){
            tmpElement = EnumHelper.stringToElementType(elementCardTyp);
            //Deutsch übersetzung
            if (tmpElement.name().toLowerCase().equals("feuer")){
                tmpElement = ElementTyp.FIRE;
            }else if (tmpElement.name().toLowerCase().equals("wasser")){
                tmpElement = ElementTyp.WATER;
            }else if (tmpElement.name().toLowerCase().equals("normal")){
                tmpElement = ElementTyp.REGULAR;
            }
            if(tmpElement == null) {
                tmpElement = ElementTyp.UNDEF;
            }
        }
        this.name = name;
        this.damage = damage;
        this.elementTyp = tmpElement;
        this.cardType = tmpCard;
    }



    /**
     * Prüft ob die Karte gesperrt ist
     * @return True wenn die Karte gesperrt ist
     */
    public boolean isLocked() {
        return locked;
    }

    /**
     * Setzt die sperre der Karte
     * @param locked True bedeuted gesperrt
     */
    public void setLocked(boolean locked) {
        this.locked = locked;
    }

    /**
     * Holt den Namen der at.reisinger.Card
     * @return Name der at.reisinger.Card
     */
    @JsonGetter
    public String getName() {
        return this.name;
    }

    /**
     * Holt den Damage der at.reisinger.Card
     * @return Damage der at.reisinger.Card
     */
    @JsonGetter
    public double getDamage() {
        return this.damage;
    }

    /**
     * Holt den ElementType der at.reisinger.Card
     * @return ElementType der at.reisinger.Card
     */
    @JsonGetter
    public ElementTyp getElementTyp() {
        return this.elementTyp;
    }

    /**
     * Holt den at.reisinger.CardType der at.reisinger.Card
     * @return at.reisinger.CardType der at.reisinger.Card
     */
    @JsonGetter
    public CardType getCardType() {
        return this.cardType;
    }

    /**
     * Berechnet die Wirksamkeit gegen eine Andere card. Die at.reisinger.Card im Parameter wird angegriffen
     * @param toCeck at.reisinger.Card gegen welche die Wirksamkeit geprüft werden soll
     * @return Gibt die Wirksamkeit zurück
     * @throws InternalError Wenn die Effectifeness von den 2 at.reisinger.Cards nicht berechnet werden kann
     */
    @JsonGetter
    public EffectivnessType getEffectivenessAgainst(Card toCeck) {
        if(toCeck.getCardType() == CardType.MONSTER){
            if(this.cardType == CardType.MONSTER){
                return EffectivnessType.NOEFFECT;
            }else if (this.cardType == CardType.SPELL){

            }
        }else if (toCeck.getCardType() == CardType.SPELL){
            if ((toCeck.getElementTyp() == ElementTyp.FIRE && this.elementTyp == ElementTyp.WATER) || (toCeck.getElementTyp() == ElementTyp.NORMAL && this.elementTyp == ElementTyp.FIRE) || (toCeck.getElementTyp() == ElementTyp.WATER && this.elementTyp == ElementTyp.NORMAL)){
                return EffectivnessType.EFFECTIVE;
            }else if (this.elementTyp == ElementTyp.FIRE && toCeck.getElementTyp() == ElementTyp.WATER){
                return EffectivnessType.NOTEFFECTIVE;
            }else if ((toCeck.getElementTyp() == ElementTyp.NORMAL && this.cardType == CardType.MONSTER && this.elementTyp == ElementTyp.NORMAL)){
                return EffectivnessType.NOEFFECT;
            }
        }
        throw new InternalError("Konnte die Effectiveness von den at.reisinger.Cards nicht berechnen");
    }

    /**
     * Setztden namen der at.reisinger.Card
     * @param neuerName Name der at.reisinger.Card
     */
    @JsonSetter
    public void setName(String neuerName) {
        this.name = neuerName;
    }

    /**
     * Setzt den Damage der at.reisinger.Card
     * @param damage Der Damage
     */
    @JsonSetter
    public void setDamage(int damage) {
        this.damage = damage;
    }

    /**
     * Setzt den ElementType der at.reisinger.Card
     * @param elementTyp Der ElementType
     */
    @JsonSetter
    public void setElementType(ElementTyp elementTyp) {
        this.elementTyp = elementTyp;
    }

    /**
     * Testet ob die beiden Karten gleich sind
     * @param card at.reisinger.Card die geprüft werden soll
     * @return True wenn die Karten übereinstimmen
     */
    public boolean equals(Card card){
        if(card == null) return false;
        if(this.name == card.getName() && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage()){
            return true;
        }else {
            return false;
        }
    }
}