using Implab;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace Implab.Automaton {
    /// <summary>
    /// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.
    /// </summary>
    /// <remarks>
    /// Indexed alphabets are usefull in bulting efficient translations from source alphabet
    /// to the input alphabet of the automaton. It's assumed that the index to the symbol match
    /// is well known and documented.
    /// </remarks>
    public abstract class IndexedAlphabetBase<T> : IAlphabetBuilder<T> {
        int m_nextId = 1;
        readonly int[] m_map;

        protected IndexedAlphabetBase(int mapSize) {
            m_map = new int[mapSize];
        }

        protected IndexedAlphabetBase(int[] map) {
            Debug.Assert(map != null && map.Length > 0);
            Debug.Assert(map.All(x => x >= 0));

            m_map = map;
            m_nextId = map.Max() + 1;
        }

        public int DefineSymbol(T symbol) {
            var index = GetSymbolIndex(symbol);
            if (m_map[index] == DFAConst.UNCLASSIFIED_INPUT)
                m_map[index] = m_nextId++;
            return m_map[index];
        }

        public int DefineSymbol(T symbol, int cls) {
            var index = GetSymbolIndex(symbol);
            m_map[index] = cls;
            m_nextId = Math.Max(cls + 1, m_nextId);
            return cls;
        }

        public int DefineClass(IEnumerable<T> symbols) {
            return DefineClass(symbols, m_nextId);
        }

        public int DefineClass(IEnumerable<T> symbols, int cls) {
            Safe.ArgumentNotNull(symbols, "symbols");
            symbols = symbols.Distinct();

            foreach (var symbol in symbols)
                m_map[GetSymbolIndex(symbol)] = cls;
            
            m_nextId = Math.Max(cls + 1, m_nextId);

            return cls;
        }

        public virtual int Translate(T symbol) {
            return m_map[GetSymbolIndex(symbol)];
        }

        public int Count {
            get { return m_nextId; }
        }

        public bool Contains(T symbol) {
            return true;
        }

        public IEnumerable<T> GetSymbols(int cls) {
            for (var i = 0; i < m_map.Length; i++)
                if (m_map[i] == cls)
                    yield return GetSymbolByIndex(i);
        }

        public abstract int GetSymbolIndex(T symbol);

        public abstract T GetSymbolByIndex(int index);

        public abstract IEnumerable<T> InputSymbols { get; }

        /// <summary>
        /// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.
        /// </summary>
        /// <returns>The translation map.</returns>
        public int[] GetTranslationMap() {
            return m_map;
        }
    }
}