/*
* OptionParse Class: to parse command line arguments
*
* Author:		Daniele Simonin
* Created:		13 April 2006
* Site:         http://www.melodycode.com 
*
* Version:		1.0.0
*/

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Collections.Specialized;

namespace CommandLine {

    /// <summary>Class <c>OptionParse</c> to parse command line arguments.</summary>
    public class OptionParse {

        /// <summary>Class <c>Option</c> to refer a single command line option.</summary>
        private class Option {

            public string short_o, long_o, dest, help, metavar;
            public bool requested, boolean;
            private static int maxL=0;

            public Option(string short_o, string long_o, string dest, string help, string metavar, bool requested, bool boolean) {
                this.short_o=short_o;
                this.long_o=long_o;
                this.dest=dest;
                this.help=help;
                if (!boolean) {
                    this.metavar=metavar;
                }
                string c=short_o+" "+metavar+", "+long_o+" "+metavar;
                maxL=c.Length>maxL?c.Length:maxL;
                this.requested=requested;
                this.boolean=boolean;
            }

            private static string putspaces(string s,int index,int n) {
                string spaces="";
                for (int i=0; i<n; i++) {
                    spaces+=" ";
                }
                return s.Substring(0, index)+spaces+s.Substring(index);
            }

            public override string ToString() {
                string ritorno="";
                int lungMax=Console.WindowWidth;
                int spaceL=3;
                int lSx=maxL+spaceL;
                int lDx=lungMax-lSx;
                ritorno+=short_o+" "+metavar;
                ritorno+=", "+long_o+" "+metavar;
                #region Tabs War
                int lungSx=ritorno.Length;
                if (help.Length>lDx) {
                    int lim=help.Length/lDx;
                    int index=0;
                    for (int i=1; i<=lim; i++) {
                        if (i==1) {
                            index=lDx;
                        } else {
                            index+=lungMax;
                        }
                        help=putspaces(help, index, lSx);
                    }
                }
                ritorno+=putspaces(help, 0, lSx-lungSx);
                if (help.Length!=lDx) ritorno+="\n";
                #endregion
                return ritorno;
            }
        }

        private List<Option> options=new List<Option>();
        private string program, version, description, usage;
        private Dictionary<string, Object> ritorno=new Dictionary<string, Object>();

        /// <summary>OptionParse contructor.</summary>
        /// <param name="program">Program name's</param>
        /// <param name="version">Program version's</param>
        /// <param name="description">Program description's</param>
        /// <param name="usage">Usage string</param>
        /// <example>This sample shows how to call the OptionParse constructor.
        /// <code>OptionParse parser=new OptionParse("Program", "1.0","%program %version is a program", "Usage: %program [option]");</code>
        /// </example>
        public OptionParse(string program, string version, string description, string usage) {
            this.program=program;
            this.version=version;
            this.description=description.Replace("%program", program).Replace("%version", version);
            this.usage=usage.Replace("%program", program).Replace("%version", version);
        }

        /// <summary>Add command line option</summary>
        /// <param name="short_o">Short option (example: -o)</param>
        /// <param name="long_o">Long option (example: --option)</param>
        /// <param name="dest">Destination key (example: option)</param>
        /// <param name="help">Help text (example: This is a option)</param>
        /// <param name="metavar">Metavar option (example: OPTION). If boolean is true, this arguments will be ignored.</param>
        /// <param name="requested">Is requested? (example: true)</param>
        /// <param name="boolean">Is a boolean option's? (example: false)</param>
        /// <exception cref="System.ArgumentException">Thrown when short_o or long_o are wrong.</exception>
        /// <example>This sample shows how to call the addOption method.
        /// <code>parser.addOption("-o", "--option", "option", "Indicate you %metavar", "OPTION", true, false);</code>
        /// </example>
        public void addOption(string short_o, string long_o, string dest, string help, string metavar, bool requested, bool boolean) {
            if (!isShortOpt(short_o)) {
                throw new ArgumentException("addOption method: argument short_o wrong. Example: -t", short_o);
            } else if (!isLongOpt(long_o)) {
                throw new ArgumentException("addOption method: argument long_o wrong. Example: --text", long_o);
            } else {
                options.Add(new Option(short_o, long_o, dest, help.Replace("%metavar", metavar), metavar, requested, boolean));
            }
        }

        /// <summary>Parse command line arguments.</summary>
        /// <param name="args">Array to string of arguments</param>
        public void parseArgs(string[] args) {
            foreach (Option option in options) {
                bool insert=false;
                for (int i=0; i<args.Length; i++) {
                    if ((isShortOpt(args[i])||isLongOpt(args[i]))&&(args[i]==option.short_o||args[i]==option.long_o)) {
                        if (!ritorno.ContainsKey(option.dest)) {
                            if (option.boolean) {
                                insert=true;
                                ritorno.Add(option.dest, true);
                            } else {
                                if ((i+1)<args.Length&&isArg(args[i+1])) {
                                    insert=true;
                                    ritorno.Add(option.dest, args[++i]);
                                }
                            }
                        }
                    }
                }
                if (!insert&&option.requested) {
                    Console.WriteLine(this);
                    Environment.Exit(0);
                }
            }
        }

        /// <summary>Parse command line arguments.</summary>
        public void parseArgs() {
            parseArgs(Environment.GetCommandLineArgs());
        }

        private static bool PredicatedRequested(Option s) {
            return s.requested;
        }

        private static bool PredicatedFacoltative(Option s) {
            return !PredicatedRequested(s);
        }

        private static bool isShortOpt(string s) {
            return Regex.IsMatch(s, @"(^-\w\b)", RegexOptions.IgnoreCase|RegexOptions.Compiled|RegexOptions.Singleline);
        }

        private static bool isLongOpt(string s) {
            return Regex.IsMatch(s, @"(^-{2}\w{2,})", RegexOptions.IgnoreCase|RegexOptions.Compiled|RegexOptions.Singleline);
        }

        private static bool isArg(string s) {
            return !(isShortOpt(s)||isLongOpt(s));
        }

        /// <summary>String rappresentation of help menu.</summary>
        public override string ToString() {
            string ritorno;
            ritorno=description+"\n\n";
            ritorno+=usage+"\n";
            if (options.Exists(new Predicate<Option>(PredicatedRequested))) {
                ritorno+="\nRequested arguments:\n";
                foreach (Option option in options) {
                    if (option.requested) {
                        ritorno+=option;
                    }
                }
            }
            if (options.Exists(new Predicate<Option>(PredicatedFacoltative))) {
                ritorno+="\nOptional arguments:\n";
                foreach (Option option in options) {
                    if (!option.requested) {
                        ritorno+=option;
                    }
                }
            }
            return ritorno;
        }

        /// <summary>Get parameter value.</summary>
        public Object this[string dest] {
            get {
                return (ritorno[dest]);
            }
        }
    }
}