//////////////////////////////////////////////////////////////////////////////
// Project: Ob51
// License: Apache License, Version 2.0; for details see LICENSE file
// Copyright: see NOTICE file
//
// Last file commit: $Revision: 215 $   Made by: $Author: avek $
//////////////////////////////////////////////////////////////////////////////  
using System;
using System.Collections.Generic;
using IEnumerable = System.Collections.IEnumerable;
using IEnumerator = System.Collections.IEnumerator;
using System.Text;

namespace Ob51.Compiler
{
    /// <summary>
    /// Storage for error and warning messages generated during the compilation.
    /// </summary>
    public class IssueList : IEnumerable<Issue>
    {
        #region Internal data storage
        /// <summary>
        /// Internal storage for the list of <see cref="Issue"/> instances.
        /// </summary>
        private List<Issue> list = new List<Issue>(20);

        /// <summary>
        /// Internal counter of the errors.
        /// </summary>
        private uint errorCount = 0u;

        /// <summary>
        /// Internal counter of the warnings.
        /// </summary>
        private uint warningCount = 0u;

        /// <summary>
        /// Internal counter of the notes.
        /// </summary>
        private uint noteCount = 0u;
        #endregion

        /// <summary>
        /// Adds <see cref="Issue"/>, the information about the error or warning,
        /// to this list.
        /// </summary>
        /// <param name="issue"><see cref="Issue"/> to add</param>
        public void Add(Issue issue)
        {
            list.Add(issue);
            switch (issue.Severity)
            {
                case Issue.Severities.Warning:
                    ++warningCount;
                    break;
                case Issue.Severities.Note:
                    ++noteCount;
                    break;
                case Issue.Severities.FatalError:
                case Issue.Severities.Error:
                default:
                    ++errorCount;
                    break;
            }
        }

        /// <summary>
        /// Registers <see cref="Issue"/> in the given log. If no log is given,
        /// throws <see cref="Issue.UnableToRecordIssueException"/>.
        /// </summary>
        /// <param name="issue">Error, warning or note to record</param>
        /// <param name="list"><see cref="IssueList"/> to record in or null</param>
        public static void Record(Issue issue, IssueList list)
        {
            if (issue == null)
                throw new ArgumentNullException("issue");
            if (list == null)
                throw new Issue.UnableToRecordIssueException(issue);
            list.Add(issue);
        }
        /// <summary>
        /// Creates an <see cref="Issue"/> based on parameters given and
        /// registers it in the given log. If no log provided, throws
        /// <see cref="Issue.UnableToRecordIssueException"/>.
        /// </summary>
        /// <param name="severity">Severity code of the issue</param>
        /// <param name="code">Numeric status code of the issue</param>
        /// <param name="message">Issue description</param>
        /// <param name="src"><see cref="InternalTree.ProgramNode"/> that
        /// produced the issue</param>
        /// <param name="list"><see cref="IssueList"/> to record in</param>
        public static void Record(Issue.Severities severity,
                                  uint code,
                                  string message,
                                  InternalTree.ProgramNode src,
                                  IssueList list)
        {
            Record(new Issue(severity, code, message, src), list);
        }

        /// <summary>
        /// Removes all the <see cref="Issue"/> instances from this list.
        /// </summary>
        public void Clear()
        {
            list.Clear();
            errorCount = warningCount = noteCount = 0u;
        }

        /// <summary>
        /// Indicates whether this <see cref="IssueList"/> is empty.
        /// </summary>
        public bool IsEmpty { get { return list.Count == 0; } }

        /// <summary>
        /// Indicates whether any <see cref="Issue.Severities.Error"/>s or
        /// <see cref="Issue.Severities.FatalError"/>s are present in this list.
        /// </summary>
        public bool ContainsErrors { get { return errorCount != 0; } }

        /// <summary>
        /// Indicates whether any <see cref="Issue.Severities.Warning"/>s are
        /// present in this list.
        /// </summary>
        public bool ContainsWarnings { get { return warningCount != 0; } }

        /// <summary>
        /// Indicates whether any <see cref="Issue.Severities.Note"/>s are
        /// present in this list.
        /// </summary>
        public bool ContainsNotes { get { return noteCount != 0; } }

        /// <summary>
        /// The number of <see cref="Issue"/>s in this list.
        /// </summary>
        public int Count { get { return list.Count; } }

        /// <summary>
        /// Default read only indexer for <see cref="IssueList"/>.
        /// </summary>
        /// <param name="position">Index of the <see cref="Issue"/> to get</param>
        /// <returns><see cref="Issue"/> at index <paramref name="position"/></returns>
        public Issue this[int position] { get { return list[position]; } }

        /// <summary>
        /// <see cref="IEnumerable&lt;Issue&gt;"/> implementation method that
        /// returns generic <see cref="IEnumerator&lt;Issue&gt;"/>
        /// </summary>
        /// <returns>Generic enumerator</returns>
        public IEnumerator<Issue> GetEnumerator()
        {
            return list.GetEnumerator();
        }

        /// <summary>
        /// <see cref="IEnumerable"/> implementation method that returns
        /// non-generic <see cref="IEnumerator"/>.
        /// </summary>
        /// <returns>Non-generic enumerator</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
    }
}