using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 触发条件基类
/// </summary>
public abstract class ConditionBase
{

    public ConditionBase()
    {
    }

    public abstract bool Evaluate();

}


/// <summary>
/// 总是满足
/// </summary>
public sealed class ConditionAlways : ConditionBase
{
    public override bool Evaluate()
    {
        return true;
    }
}

/// <summary>
/// 总是不满足
/// </summary>
public sealed class ConditionAlwaysNot : ConditionBase
{
    public override bool Evaluate()
    {
        return false;
    }
}

/// <summary>
/// 两个condition都达成才会返回真
/// </summary>
public sealed class ConditionAnd : ConditionBase
{
    ConditionBase m_FirstCondition, m_LastCondition;


    public ConditionAnd(ConditionBase first, ConditionBase last)
        : base()
    {
        m_FirstCondition = first;
        m_LastCondition = last;
    }

    public override bool Evaluate()
    {
        return m_FirstCondition.Evaluate() && m_LastCondition.Evaluate();
    }
}

/// <summary>
/// 两个condition至少一个达成才会返回真
/// </summary>
public sealed class ConditionOr : ConditionBase
{
    ConditionBase m_FirstCondition, m_LastCondition;


    public ConditionOr(ConditionBase first, ConditionBase last)
        : base()
    {
        m_FirstCondition = first;
        m_LastCondition = last;
    }

    public override bool Evaluate()
    {
        return m_FirstCondition.Evaluate() || m_LastCondition.Evaluate();
    }
}


/// <summary>
/// 两个condition都不达成才会返回真
/// </summary>
public sealed class ConditionNone : ConditionBase
{
    ConditionBase m_FirstCondition, m_LastCondition;

    public ConditionNone(ConditionBase first, ConditionBase last)
        : base()
    {
        m_FirstCondition = first;
        m_LastCondition = last;
    }

    public override bool Evaluate()
    {
        return !m_FirstCondition.Evaluate() && !m_LastCondition.Evaluate();
    }
}


/// <summary>
/// 多个condition都达成才会返回真
/// </summary>
public sealed class ConditionMultiAnd : ConditionBase
{
    List<ConditionBase> m_Conditions;

    public ConditionMultiAnd(List<ConditionBase>  conditions)
        : base()
    {
        m_Conditions.AddRange(conditions);
    }

    public override bool Evaluate()
    {
        foreach(var condition in m_Conditions)
        {
            if(!condition.Evaluate())
                return false;
        }
        return true;
    }
}

/// <summary>
/// 多个condition至少一个达成才会返回真
/// </summary>
public sealed class ConditionMultiOr : ConditionBase
{
    List<ConditionBase> m_Conditions;

    public ConditionMultiOr(List<ConditionBase> conditions)
        : base()
    {
        m_Conditions.AddRange(conditions);
    }

    public override bool Evaluate()
    {
        foreach (var condition in m_Conditions)
        {
            if (condition.Evaluate())
                return true;
        }
        return false;
    }
}

/// <summary>
/// 多个condition都不达成才会返回真
/// </summary>
public sealed class ConditionMultiNone : ConditionBase
{
    List<ConditionBase> m_Conditions;

    public ConditionMultiNone(List<ConditionBase> conditions)
        : base()
    {
        m_Conditions.AddRange(conditions);
    }

    public override bool Evaluate()
    {
        foreach (var condition in m_Conditions)
        {
            if (condition.Evaluate())
                return false;
        }
        return true;
    }
}