// Copyright (c) 2007 Omer Rauchwerger (a.k.a rauchy) (omer@rauchy.net)
// All rights reserved.
//
// This file is part of Regionerate.
// 
// This program is free software; you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by 
// the Free Software Foundation; either version 3 of the License, 
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

using System.Collections.Generic;
using System.Globalization;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using Rauchy.Regionerate.ServiceLayer.Components.Services;
using Rauchy.Regionerate.Shared.Components;

namespace Rauchy.Regionerate.Presentation.Addins.NAnt
{
    /// <summary>
    /// An NAnt <see cref="Task"/> which Regionerates files, projects and solutions.
    /// </summary>
    [ TaskName( "rgn" ) ]
    public class RegionerateTask : Task
    {
        #region Fields (6) 

        private FileSet _ignoredFiles;
        private FileSet _ignoredProjects;
        private string _layout;
        private readonly LogWriter _logWriter;
        private FileSet _projects;
        private FileSet _solutions;

        #endregion Fields 

        #region Constructors (1) 

        /// <summary>
        /// Initializes a new instance of the <see cref="RegionerateTask"/> class.
        /// </summary>
        public RegionerateTask()
        {
            _logWriter = new LogWriter( this, Level.Info, CultureInfo.InvariantCulture );
        }

        #endregion Constructors 

        #region Properties (7) 

        /// <summary>
        /// Gets or sets the files within projects that will not be Regionerated.
        /// </summary>
        [ BuildElement( "ignoredFiles", Required = false ) ]
        public FileSet IgnoredFiles
        {
            get
            {
                return _ignoredFiles;
            }
            set
            {
                _ignoredFiles = value;
            }
        }

        /// <summary>
        /// Gets or sets the projects within solutions that will not be Regionerated.
        /// </summary>
        [ BuildElement( "ignoredProjects", Required = false ) ]
        public FileSet IgnoredProjects
        {
            get
            {
                return _ignoredProjects;
            }
            set
            {
                _ignoredProjects = value;
            }
        }

        /// <summary>
        /// Gets or sets the Code Layout to Regionerate by.
        /// </summary>
        [ TaskAttribute( "layout", Required = false ) ]
        public string Layout
        {
            get
            {
                return _layout;
            }
            set
            {
                _layout = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether information should be prompted or not.
        /// </summary>
        /// <value><c>true</c> if [no info]; otherwise, <c>false</c>.</value>
        [ TaskAttribute( "noInfo", Required = false ) ]
        public bool NoInfo
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets a value indicating whether warnings should be prompted or not.
        /// </summary>
        /// <value><c>true</c> if [no warn]; otherwise, <c>false</c>.</value>
        [ TaskAttribute( "noWarn", Required = false ) ]
        public bool NoWarn
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the projects which will be Regionerated.
        /// </summary>
        [ BuildElement( "projects", Required = false ) ]
        public FileSet Projects
        {
            get
            {
                return _projects;
            }
            set
            {
                _projects = value;
            }
        }

        /// <summary>
        /// Gets or sets the solutions which will be Regionerated.
        /// </summary>
        [ BuildElement( "solutions", Required = false ) ]
        public FileSet Solutions
        {
            get
            {
                return _solutions;
            }
            set
            {
                _solutions = value;
            }
        }

        #endregion Properties 

        #region Methods (6) 

        // Protected Methods (1) 

        // [rgn] Protected Methods (1)
        /// <summary>
        /// Executes the task.
        /// </summary>
        protected override void ExecuteTask()
        {
            // Register for information only if NoInfo is not set.
            if ( !NoInfo )
            {
                Output.OnInformationSubmitted += Output_OnInformationSubmitted;
            }

            // Always register to warnings. (if NoWarn is set, NonCritical warnings will not be displayed)
            Output.OnWarningSubmitted += Output_OnWarningSubmitted;

            string[] ignoredProjects = GetIncludes( _ignoredProjects );
            string[] ignoredFiles = GetIncludes( _ignoredFiles );

            #region Handle Solutions

            string[] includedSolutions = GetIncludes( _solutions );
            if ( includedSolutions.Length > 0 )
            {
                SolutionService service = GetSolutionService( ignoredProjects, ignoredFiles, _layout );
                foreach ( string solution in includedSolutions )
                {
                    service.Process( solution );
                }
            }

            #endregion

            #region Handle Projects

            string[] includedProjects = GetIncludes( _projects );
            if ( includedProjects.Length > 0 )
            {
                ProjectService service = GetProjectService( ignoredFiles, _layout );
                foreach ( string project in includedProjects )
                {
                    service.Process( project );
                }
            }

            #endregion
        }

        // Private Methods (5) 

        // [rgn] Private Methods (5)
        /// <summary>
        /// Gets the included files in a <see cref="FileSet"/>.
        /// </summary>
        /// <param name="fileSet">The file set.</param>
        private static string[] GetIncludes( FileSet fileSet )
        {
            if ( fileSet == null )
            {
                return new string[] {};
            }

            List<string> includes = new List<string>();
            foreach ( string include in fileSet.Includes )
            {
                includes.Add( include );
            }
            return includes.ToArray();
        }

        /// <summary>
        /// Instanciates the correct <see cref="ProjectService"/>.
        /// </summary>
        /// <param name="ignoredFiles">The ignored files.</param>
        /// <param name="layout">The Code Layout path.</param>
        /// <returns></returns>
        private static ProjectService GetProjectService( string[] ignoredFiles, string layout )
        {
            ProjectService service;
            if ( layout == null )
            {
                // Use the default Code Layout
                service = new CSharpProjectService( ignoredFiles );
            }
            else
            {
                service = new CSharpProjectService( layout, ignoredFiles );
            }
            return service;
        }

        /// <summary>
        /// Instanciates the correct <see cref="SolutionService"/>.
        /// </summary>
        /// <param name="ignoredFiles">The ignored files.</param>
        /// <param name="ignoredProjects">The ignored projects.</param>
        /// <param name="layout">The Code Layout path.</param>
        /// <returns></returns>
        private static SolutionService GetSolutionService( string[] ignoredProjects,
                                                           string[] ignoredFiles,
                                                           string layout )
        {
            SolutionService service;
            if ( layout == null )
            {
                // Use the default Code Layout
                service = new SolutionService( ignoredProjects, ignoredFiles );
            }
            else
            {
                service = new SolutionService( layout, ignoredProjects, ignoredFiles );
            }
            return service;
        }

        private void Output_OnInformationSubmitted( string text )
        {
            string formattedText = string.Format( "Information: {0}.", text );

            _logWriter.WriteLine( formattedText );
        }

        private void Output_OnWarningSubmitted( string text, Output.WarningLevel level )
        {
            if ( ( NoWarn ) &&
                 ( level == Output.WarningLevel.NonCritical ) )
            {
                return;
            }

            string formattedText = string.Format( "{0} warning: {1}.", level, text );

            _logWriter.WriteLine( formattedText );
        }

        #endregion Methods 
    }
}