package at.reisinger;

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;

    /**
     * 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){
        ElementTyp tmpElement = stringToElementType(elementCardTyp);
        if(tmpElement == null){
            tmpElement = ElementTyp.UNDEF;
        }
        CardType tmpCard = stringToCardType(elementCardTyp);
        if(tmpCard == null){
            tmpCard = CardType.UNDEF;
        }
        this.name = name;
        this.damage = damage;
        this.elementTyp = tmpElement;
        this.cardType = tmpCard;
    }

    /**
     * Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück
     * @param elementTypeString elementType als String
     * @return Passender Element Type oder null falls nicht gefunden
     */
    private ElementTyp stringToElementType(String elementTypeString){
        for (ElementTyp e : ElementTyp.values()) {
            if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) {
                return e;
            }
        }
        return null;
    }

    /**
     * Wenn ein String als cardType vorhanden ist, dann gibt er den passenden cardType zurück
     * @param cardTypeString cardType als String
     * @return Passender Card Type oder null falls nicht gefunden
     */
    private CardType stringToCardType(String cardTypeString){
        for (CardType me : CardType.values()) {
            if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
                return me;
            }
        }
        return null;
    }

    /**
     * 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;
        }
    }
}