// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
namespace Microsoft.Tools.ServiceModel.SvcUtil.XmlSerializer
{
    using System;
    using System.Globalization;
    using System.Collections.Generic;
    using System.Text.RegularExpressions;
    using System.IO;
 
    internal enum SwitchType
    {
        Flag,
        SingletonValue,
        ValueList
    }
 
    internal class CommandSwitch
    {
        private readonly string _name;
        private readonly string _abbreviation;
        private readonly SwitchType _switchType;
 
        internal CommandSwitch(string name, string abbreviation, SwitchType switchType)
        {
            //ensure name doesn't start with '--' and abbreviation doesn't start with '-'
            //also convert to lower-case
            if (name.StartsWith("--"))
                name = name.Substring(2);
          
            _name = name.ToLower(CultureInfo.InvariantCulture);
 
            if (abbreviation.StartsWith("-"))
                abbreviation = abbreviation.Substring(1);
 
            _abbreviation = abbreviation.ToLower(CultureInfo.InvariantCulture);
 
            _switchType = switchType;
        }
 
        internal string Name
        {
            get { return _name; }
        }
 
#if NotUsed
        internal string Abbreviation
        {
            get { return abbreviation; }
        }
#endif
 
        internal SwitchType SwitchType
        {
            get { return _switchType; }
        }
 
        internal bool Equals(string other)
        { 
            //ensure that compare doesn't start with '--' or '-'
            //also convert to lower-case
            if (other.StartsWith("--"))
                other = other.Substring(2);
            else if (other.StartsWith("-"))
                other = other.Substring(1);
            
            //if equal to name, then return the OK
            if (_name.Equals(other, StringComparison.InvariantCultureIgnoreCase))
                return true;
            //now check abbreviation
            return _abbreviation.Equals(other, StringComparison.InvariantCultureIgnoreCase);
        }
 
        internal static CommandSwitch FindSwitch(string name, CommandSwitch[] switches)
        {
            foreach (CommandSwitch cs in switches)
                if (cs.Equals(name))
                    return cs;
            //if no match found, then return null
            return null;
        }
    }
 
    internal class ArgumentDictionary
    {
        private Dictionary<string, IList<string>> _contents;
 
        internal ArgumentDictionary(int capacity)
        {
            _contents = new Dictionary<string, IList<string>>(capacity);
        }
 
        internal void Add(string key, string value)
        {
            IList<string> values;
            if (!ContainsArgument(key))
            {
                values = new List<string>();
                Add(key, values);
            }
            else
                values = GetArguments(key);
 
            values.Add(value);
        }
 
        internal string GetArgument(string key)
        {
            IList<string> values;
            if (_contents.TryGetValue(key.ToLower(CultureInfo.InvariantCulture), out values))
            {
#if SM_TOOL
                Tool.Assert((values.Count == 1), "contains more than one argument please call GetArguments");
#endif
                return values[0];
            }
#if SM_TOOL
            Tool.Assert(false, "argument was not specified please call ContainsArgument to check this");
#endif
 
            return null; // unreachable code but the compiler doesn't know this.
        }
 
        internal IList<string> GetArguments(string key)
        {
            IList<string> result;
            if (!_contents.TryGetValue(key.ToLower(CultureInfo.InvariantCulture), out result))
                result = new List<string>();
            return result;
        }
 
        internal bool ContainsArgument(string key)
        {
            return _contents.ContainsKey(key.ToLower(CultureInfo.InvariantCulture));
        }
 
        internal void Add(string key, IList<string> values)
        {
            _contents.Add(key.ToLower(CultureInfo.InvariantCulture), values);
        }
 
        internal int Count
        {
            get { return _contents.Count; }
        }
    }
 
    internal static class CommandParser
    {
        internal static ArgumentDictionary ParseCommand(string[] cmd, CommandSwitch[] switches)
        {
            ArgumentDictionary arguments;   //switches/values from cmd line
 
            string arg;                     //argument to test next
            CommandSwitch argSwitch;        //switch corresponding to that argument
            string argValue;                //value corresponding to that argument
            int delim;                      //location of value delimiter (':' or '=')
 
            arguments = new ArgumentDictionary(cmd.Length);
            foreach (string s in cmd)
            {
                arg = s;
                bool argIsFlag = true;
 
                //if argument does not start with switch indicator, place into "default" arguments
                if (arg[0] != '-')
                {
                    arguments.Add(String.Empty, arg);
                    continue;
                }
 
                //if we have something which begins with '--' or '-', throw if nothing after it
                if (arg == "-" || arg == "--")
                    throw new ArgumentException(SR.Format(SR.ErrSwitchMissing, arg));
 
                //yank switch indicator ('--' or '-') off of command argument
                if (arg[1] != '-')
                    arg = arg.Substring(1);
                else
                    arg = arg.Substring(2);
 
                //check to make sure delimiter does not start off switch
                delim = arg.IndexOfAny(new char[] { ':', '=' });
                if (delim == 0)
                    throw new ArgumentException(SR.Format(SR.ErrUnexpectedDelimiter));
 
                //if there is no value, than create a null string
                if (delim == (-1))
                    argValue = String.Empty;
                else
                {
                    //assume valid argument now; must remove value attached to it
                    //must avoid copying delimeter into either arguments
                    argValue = arg.Substring(delim + 1);
                    arg = arg.Substring(0, delim);
                    argIsFlag = false;
                }
 
                //check if this switch exists in the list of possible switches
                //if no match found, then throw an exception
                argSwitch = CommandSwitch.FindSwitch(arg.ToLower(CultureInfo.InvariantCulture), switches);
                if (argSwitch == null)
                {
                    // Paths start with "/" on Unix, so the arg could potentially be a path.
                    // If we didn't find any matched option, check and see if it's a path.
                    string potentialPath = "/" + arg;
                    if (File.Exists(potentialPath))
                    {
                        arguments.Add(string.Empty, potentialPath);
                        continue;
                    }
 
                    throw new ArgumentException(SR.Format(SR.ErrUnknownSwitch, arg.ToLower(CultureInfo.InvariantCulture)));
                }
 
                //check if switch is allowed to have a value
                // if not and a value has been specified, then thrown an exception
                if (argSwitch.SwitchType == SwitchType.Flag)
                {
                    if (!argIsFlag)
                        throw new ArgumentException(SR.Format(SR.ErrUnexpectedValue, arg.ToLower(CultureInfo.InvariantCulture)));
                }
                else
                {
                    if (argIsFlag)
                        throw new ArgumentException(SR.Format(SR.ErrExpectedValue, arg.ToLower(CultureInfo.InvariantCulture)));
                }
 
                //check if switch is allowed to be specified multiple times
                // if not and it has already been specified and a new value has been paresd, throw an exception
                if (argSwitch.SwitchType != SwitchType.ValueList && arguments.ContainsArgument(argSwitch.Name))
                {
                    throw new ArgumentException(SR.Format(SR.ErrSingleUseSwitch, arg.ToLower(CultureInfo.InvariantCulture)));
                }
                else
                {
                    arguments.Add(argSwitch.Name, argValue);
                }
            }
 
            return arguments;
        }
    }
}