/*       Copyright (c) Eric Ledoux.  All rights reserved.       */
/* See http://www.dwell.net/terms for code sharing information. */

// SourceFile.cs
//
// Implements class SourceFile and related types.
//

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using DwellNet.CodeDoc;
using CodeDocApi.Properties;

namespace DwellNet.CodeDoc
{

public abstract class SourceFile : TokenList
{
    //////////////////////////////////////////////////////////////////////////
    // Internal Constants
    //

    internal const char LBrace = '{';

    internal const char RBrace = '}';

    internal const char LParen = '(';

    internal const char RParen = ')';

    internal const char LSquare = '[';

    internal const char RSquare = ']';

    internal const char LAngle = '<';

    internal const char RAngle = '>';

    //////////////////////////////////////////////////////////////////////////
    // Private Fields
    //

    readonly static Regex s_whiteSpaceRegex = new Regex(@"\s+");

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    List<ParsingException> m_warnings = new List<ParsingException>();

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    string m_assemblyName;

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    bool m_exceptionOnInvalidXmlComment = true;

    //////////////////////////////////////////////////////////////////////////
    // Internal Fields
    //

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    internal DocumentationSet m_docSet;

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    internal string m_sourceFileAbsolutePath;

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    internal string m_sourceFileRelativePath;

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    internal List<Topic> m_topics = new List<Topic>(100);

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    int m_sourceFileTopicId;

    //////////////////////////////////////////////////////////////////////////
    // Public Properties
    //

    public DocumentationSet DocumentationSet
    {
        get
        {
            return m_docSet;
        }
    }

    public string SourceFileAbsolutePath
    {
        [DebuggerStepThrough]
        get
        {
            return m_sourceFileAbsolutePath;
        }
    }

    public string SourceFileRelativePath
    {
        [DebuggerStepThrough]
        get
        {
            return m_sourceFileRelativePath;
        }
    }

    public string CodeHtmlFileName
    {
        get
        {
            return SourceFileRelativePath.Replace("!", "!!")
                .Replace(@"\", "!").Replace("/", "!") + ".htm";
        }
    }

    public ICollection<Topic> Topics
    {
        [DebuggerStepThrough]
        get
        {
            return new ReadOnlyCollection<Topic>(m_topics);
        }
    }

    internal List<Topic> TopicsList
    {
        [DebuggerStepThrough]
        get
        {
            return m_topics;
        }
    }

    public int SourceFileTopicId
    {
        [DebuggerStepThrough]
        get
        {
            return m_sourceFileTopicId;
        }
        [DebuggerStepThrough]
        internal set
        {
            m_sourceFileTopicId = value;
        }
    }

    public ICollection<ParsingException> Warnings
    {
        [DebuggerStepThrough]
        get
        {
            return new ReadOnlyCollection<ParsingException>(m_warnings);
        }
    }

    public string AssemblyName
    {
        [DebuggerStepThrough]
        get
        {
            return m_assemblyName;
        }
        [DebuggerStepThrough]
        internal set
        {
            m_assemblyName = value;
        }
    }

    public bool ExceptionOnInvalidXmlComment
    {
        [DebuggerStepThrough]
        get
        {
            return m_exceptionOnInvalidXmlComment;
        }
        [DebuggerStepThrough]
        internal set
        {
            m_exceptionOnInvalidXmlComment = value;
        }
    }

    //////////////////////////////////////////////////////////////////////////
    // Public Events
    //

    public event InvalidXmlCommentEventDelegate InvalidXmlComment;

#if false
    //////////////////////////////////////////////////////////////////////////
    // Public Methods
    //

    /// <summary>
    /// Generates code HTML corresponding to this source file.
    /// </summary>
    ///
    /// <param name="htmlPath">The path of the HTML output file to
    ///     generate.  This file is overwritten if it exists.</param>
    ///
    public abstract void GenerateCodeHtml(string htmlPath);
#endif

    //////////////////////////////////////////////////////////////////////////
    // Protected Methods
    //

    protected void AddXmlComment(Token token)
    {
        Debug.Assert(token.TokenType == TokenType.XmlComment);

        // delete all trailing whitespace tokens
        string space = null;
        while (true)
        {
            Token previousToken = TailToken.Previous;
            if (previousToken.TokenType == TokenType.WhiteSpace)
            {
                if (space == null)
                    space = previousToken.Text;
                else
                    space += previousToken.Text;
                previousToken.RemoveFromList();
            }
            else
                break;
        }

        // add the deleted white space (if any) to <token>
        if (space != null)
            token.Text = space + token.Text;

        // insert <token> into the linked list
        Append(token);
    }

    internal void Warning(Token token, string format, params object[] args)
    {
        m_warnings.Add(new ParsingException(m_sourceFileAbsolutePath,
            token.GetLineNumber(), format, args));
    }

    protected ParsingException Expected(Token token, string format,
        params object[] args)
    {
        throw NewParsingException(token, Resources.Expected,
            String.Format(format, args));
    }

    protected ParsingException Unexpected(Token token, string format,
        params object[] args)
    {
        throw NewParsingException(token, Resources.Unexpected,
            String.Format(format, args));
    }

    protected ParsingException NewParsingException(Token token,
        string format, params object[] args)
    {
        return new ParsingException(m_sourceFileAbsolutePath,
            token.GetLineNumber(), format, args);
    }

    protected static string Join(string s1, string delimiter,
        string s2)
    {
        if (s1 == null)
        {
            if (s2 == null)
                return null;
            else
                return s2;
        }
        else
        {
            if (s2 == null)
                return s1;
            else
                return s1 + delimiter + s2;
        }
    }

    protected static string FindCommonPrefix(string s1, string s2)
    {
        int cch = Math.Min(s1.Length, s2.Length);
        for (int ich = 0; ich < cch; ich++)
        {
            if (s1[ich] != s2[ich])
                return s1.Substring(0, ich);
        }
        return s1.Substring(0, cch);
    }

    protected void FireInvalidXmlComment(ParsingException exception)
    {
        if (InvalidXmlComment != null)
            InvalidXmlComment(exception);
    }

    //////////////////////////////////////////////////////////////////////////
    // Internal Methods
    //

    internal abstract void Load(ICollection<string> initialSymbols);

    static internal string Ellipsis(string value, int maxLength)
    {
        // perform processing described in Remarks
        value = s_whiteSpaceRegex.Replace(value, " ").Trim();
        if (value.Length > maxLength)
            return value.Substring(0, maxLength) + "...";
        else
            return value;
    }
}

public delegate void InvalidXmlCommentEventDelegate(ParsingException exception);

}