/*
 * 
 * fuzzynet: Fuzzy Logic Library for Microsoft .NET
 * Copyright (C) 2008 Dmitry Kaluzhny  (kaluzhny_dmitrie@mail.ru)
 * 
 * */

using System;
using System.Collections.Generic;

namespace AI.Fuzzy.Library
{
    /// <summary>
    /// Fuzzy inference system
    /// </summary>
    public class FuzzySystem
    {
        List<FuzzyVariable> _input = new List<FuzzyVariable>();
        List<FuzzyVariable> _output = new List<FuzzyVariable>();
        List<FuzzyRule> _rules = new List<FuzzyRule>();

        AndMethod _andMethod = AndMethod.Min;
        OrMethod _orMethod = OrMethod.Max;
        ImplicationMethod _implMethod = ImplicationMethod.Min;
        AggregationMethod _aggrMethod = AggregationMethod.Max;
        DefuzzificationMethod _defuzzMethod = DefuzzificationMethod.Centroid;

        Dictionary<FuzzyVariable, double> _inputValues = new Dictionary<FuzzyVariable, double>();

        /// <summary>
        /// Default constructor
        /// </summary>
        public FuzzySystem()
        {
        }

        /// <summary>
        /// Input linguistic variables
        /// </summary>
        public List<FuzzyVariable> Input
        {
            get { return _input; }
        }

        /// <summary>
        /// Output linguistic variables
        /// </summary>
        public List<FuzzyVariable> Output
        {
            get { return _output; }
        }

        /// <summary>
        /// Fuzzy rules
        /// </summary>
        public List<FuzzyRule> Rules
        {
            get { return _rules; }
        }

        /// <summary>
        /// And method
        /// </summary>
        public AndMethod AndMethod
        {
            get { return _andMethod; }
            set { _andMethod = value; }
        }

        /// <summary>
        /// Or method
        /// </summary>
        public OrMethod OrMethod
        {
            get { return _orMethod; }
            set { _orMethod = value; }
        }

        /// <summary>
        /// Implication method
        /// </summary>
        public ImplicationMethod ImplicationMethod
        {
            get { return _implMethod; }
            set { _implMethod = value; }
        }

        /// <summary>
        /// Aggregation method
        /// </summary>
        public AggregationMethod AggregationMethod
        {
            get { return _aggrMethod; }
            set { _aggrMethod = value; }
        }

        /// <summary>
        /// Defuzzification method
        /// </summary>
        public DefuzzificationMethod DefuzzificationMethod
        {
            get { return _defuzzMethod; }
            set { _defuzzMethod = value; }
        }

        /// <summary>
        /// Create new empty rule
        /// </summary>
        /// <returns></returns>
        public FuzzyRule EmptyRule()
        {
            return new FuzzyRule(_input, _output);
        }

        /// <summary>
        /// Parse rule from the string
        /// </summary>
        /// <param name="rule">String containing the rule</param>
        /// <returns></returns>
        public FuzzyRule ParseRule(string rule)
        {
            return FuzzyRule.Parse(rule, _input, _output);
        }

        /// <summary>
        /// Get input linguistic variable by its name
        /// </summary>
        /// <param name="name">Variable's name</param>
        /// <returns>Found variable</returns>
        public FuzzyVariable InputByName(string name)
        {
            foreach (FuzzyVariable var in _input)
            {
                if (var.Name == name)
                {
                    return var;
                }
            }

            throw new KeyNotFoundException();
        }

        /// <summary>
        /// Get output linguistic variable by its name
        /// </summary>
        /// <param name="name">Variable's name</param>
        /// <returns>Found variable</returns>
        public FuzzyVariable OutputByName(string name)
        {
            foreach (FuzzyVariable var in _output)
            {
                if (var.Name == name)
                {
                    return var;
                }
            }

            throw new KeyNotFoundException();
        }

        /// <summary>
        /// Calculate output values
        /// </summary>
        /// <param name="inputValues">Input values (format: variable - value)</param>
        /// <returns>Output values (format: variable - value)</returns>
        public Dictionary<FuzzyVariable, double> Calculate(Dictionary<FuzzyVariable, double> inputValues)
        {
            //
            // Validate input
            //
            string msg;
            if (!ValidateInputValues(inputValues, out msg))
            {
                throw new ArgumentException(msg);
            }

            //
            // Fuzzification step
            //
            Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> fuzzifiedInput =
                Fuzzify(inputValues);

            //
            // Evaluate the conditions
            //
            Dictionary<FuzzyRule, double> evaluatedConditions = EvaluateConditions(fuzzifiedInput);

            //
            // Do implication for each rule
            //
            Dictionary<FuzzyRule, IMembershipFunction> implicatedConclusions = Implicate(evaluatedConditions);

            //
            // Aggrerate the results
            //
            Dictionary<FuzzyVariable, IMembershipFunction> fuzzyResult = Aggregate(implicatedConclusions);

            //
            // Defuzzify the result
            //
            Dictionary<FuzzyVariable, double> result = Defuzzify(fuzzyResult);

            return result;
        }


        ///////////////////////////////////////////////////////////////////////
        // Intermidiate calculations

        /// <summary>
        /// Fuzzify input
        /// </summary>
        /// <param name="inputValues"></param>
        /// <returns></returns>
        public Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> Fuzzify(Dictionary<FuzzyVariable, double> inputValues)
        {
            //
            // Validate input
            //
            string msg;
            if (!ValidateInputValues(inputValues, out msg))
            {
                throw new ArgumentException(msg);
            }

            //
            // Fill results list
            //
            Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> result = new Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>>();
            foreach (FuzzyVariable var in _input)
            {
                Dictionary<FuzzyTerm, double> resultForVar = new Dictionary<FuzzyTerm, double>();
                foreach (FuzzyTerm term in var.Terms)
                {
                    resultForVar.Add(term, term.MembershipFunction.GetValue(inputValues[var]));
                }
                result.Add(var, resultForVar);
            }

            return result;
        }

        /// <summary>
        /// Evaluate conditions 
        /// </summary>
        /// <param name="fuzzifiedInput"></param>
        /// <returns></returns>
        public Dictionary<FuzzyRule, double> EvaluateConditions(Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> fuzzifiedInput)
        {
            Dictionary<FuzzyRule, double> result = new Dictionary<FuzzyRule,double>();
            foreach (FuzzyRule rule in Rules)
            {
                result.Add(rule, EvaluateCondition(rule.Condition, fuzzifiedInput));
            }

            return result;
        }


        /// <summary>
        /// Implicate rule results
        /// </summary>
        /// <param name="conditions">Rule conditions</param>
        /// <returns>Implicated conclusion</returns>
        public Dictionary<FuzzyRule, IMembershipFunction> Implicate(Dictionary<FuzzyRule, double> conditions)
        {