/*============================================================================
**
**    ERG TRANSIT SYSTEMS      Licensed software
**    (C) 2008                 All rights reserved
**
**============================================================================
**
**  Project/Product : wsdl-tools
**  Filename        : WsdlExtract.cs
**  Author(s)       : David Purdie
**
**  Description     : Extract WSDLs from Managed Web Service DLL
**
**
**  Information     :
**   Compiler       : CSHARP 1 and 2
**   Target         : Build Tools
**
**==========================================================================*/

using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Web;
using System.Web.Services;
using System.Web.Services.Description;
using System.Web.Services.Discovery;
using System.Xml;

using Microsoft.CSharp;


namespace JATS.WsdlExtractor
{

    /*
    **  Class to contain user command line options
    */
    public class CmdLineParams
    {
        public string AssemblyName;
        public string OutDir = "";
        public string Uri = "http://www.erggroup.com/";
        public int Verbose = 0;
        public ArrayList EnvPath = new ArrayList();

        /*
        **  Constructor
        */
        public CmdLineParams()
        {
            /*
            **  Add default EnvVars to the EnvPath
            **  Cover all bases
            */
            EnvPath.Add ("CS_LIB");
            EnvPath.Add ("LIB");
            EnvPath.Add ("PATH");
        }
    }


    public class App
    {
        static CmdLineParams par = new CmdLineParams();
        static CmdLineParams ParseCommandLine(string[] args)
        {
            /*
            **  Extract command line arguments - very simple
            **  Format:
            **      First must be assembly
            **      Remainder are program options of the form
            **              /x:value        (value starts at value_index)
            **         or   /x
            */
            const int value_index = 3;
            
            par.AssemblyName = args[0];
            for (int i = 1; i < args.Length; i++)
            {
                string arg = args[i];
                if (arg[0] != '/')
                {
                    throw new Exception("Incorrect command line parameter " + (i + 1) + " :" + arg);
                }

                switch (arg[1])
                {
                    case 'r':
                    case 'R':
                        par.Uri = arg.Substring(value_index);
                        break;

                    case 'p':
                    case 'P':
                        par.EnvPath.Insert( 0,arg.Substring(value_index));
                        break;
                        

                    case 'o':
                    case 'O':
                        par.OutDir = arg.Substring(value_index);
                        break;

                    case 'v':
                    case 'V':
                        par.Verbose += 1;
                        break;

                    default:
                        throw new Exception("Incorrect command line parameter " + (i + 1) + " :" + arg);
                }
            }
            return par;
        }

        /*
        **  Main entry point
        */
        static int Main(string[] args)
        {
            Console.WriteLine("Web Service WSDL Extractor");

            /*
            **  Need at least one argument
            */
            if (args.Length <= 1)
            {
                Console.WriteLine(@"Usage: WsdlExtract assembly [/r:URI] [/o:Basedir] [/p:EnvVar] [/v]");
                Console.WriteLine(@"");
                Console.WriteLine(@"assembly   - Path to Web Services DLL");
                Console.WriteLine(@"/o:Output  - Set Base Directory");
                Console.WriteLine(@"/p:EnvVar  - A path to search for required DLLs");
                Console.WriteLine(@"/r:URI     - Set web service XML namespace Uri");
                Console.WriteLine(@"/v         - Verbose. Multiple allowed");
                return -1;
            }
            par = ParseCommandLine(args);

            try
            {
                /*
                **  Locate and load assembly DLL
                **  The assembly will load - even if it can't be used
                */
                Assembly assembly = Assembly.LoadFrom(par.AssemblyName);


                /*
                **  Install an event handler to handle resolver events
                **  May be used to assist in determining DLLs that need to
                **  be loaded
                */
                AppDomain currentDomain = AppDomain.CurrentDomain;
                currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);


                if (par.Verbose > 0 )
                {
                    /*
                    **  Display a list of all assemblies references by the one just
                    **  loaded. May be useful when determining problems
                    */
                    Console.WriteLine("Referenced assemblies:");
                    foreach (AssemblyName an in assembly.GetReferencedAssemblies())
                    {
                        Console.WriteLine("    " + an.ToString());
                    }
                }

                /*
                **  Find every type in the assembly that has a [WebMethod]
                **  Extract a WSDL if any of its methods are marked
                */
                foreach (Module module in assembly.GetModules())
                {
                    foreach (Type type in module.GetTypes())
                    {
                        bool hasWebMethod = false;
                        foreach (MethodInfo method in type.GetMethods())
                        {
                            if (method.GetCustomAttributes(typeof(WebMethodAttribute), false).Length > 0)
                            {
                                hasWebMethod = true;
                                break;
                            }
                        }

                        if (hasWebMethod)
                        {
                            ExtractWsdl(type, par.Uri, par.OutDir + type.Name + ".wsdl");
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return -1;
            }
            return 0;
        }


        /// <summary>
        /// Given a web service type
        ///     Extract the WSDL
        /// </summary>
        /// <param name="type">The web service type</param>
        /// <param name="uri">The URL for the service that will be set in the constructor</param>
        /// <param name="path">The path to the .cs file that will be generated</param>

        private static void ExtractWsdl(Type type, string uri, string path)
        {
            /*
            **  Load up the type and create a reflection
            */
            ServiceDescriptionReflector reflector = new ServiceDescriptionReflector();
            reflector.Reflect(type, uri);

            if (reflector.ServiceDescriptions.Count > 1)
            {
                throw new Exception(string.Format("Don't know how to deal with multiple service descriptions in {0}",
                        type));
            }

            // Write out the basic WSDL file
            reflector.ServiceDescriptions[0].Write(path);
            Console.WriteLine("    Extracted WSDL: {1} for {0}", type.FullName, path);

        }

        /*
        **  Event Handler: ResolveEvents
        **  Called when the Assembly Loader has tried all the normal avenues
        **  Atempt to locate the required DLL within the toolset library
        **  path.
        **
        **  A bit ugly
        **      - Take the name of required assembly
        **      - Tac a .DLL to the end
        **      - Attempt to locate it in the configured EnvVar
        **      - If found, then load it
        **          - Check that its the correct version
        */
        static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args)
        {
            if (par.Verbose > 0 )
            {
                Console.WriteLine("Need to Resolve: " + args.Name);
            }
            string Name =  args.Name.Split(',')[0] + ".DLL";

            foreach (string Var in par.EnvPath )
            {
                if (par.Verbose > 0 )
                    Console.WriteLine("Use EnvVar: " + Var);
                string Path = Environment.GetEnvironmentVariable(Var);

                /*
                **  Ignore EnvVars that don't exist
                */
                if ( Path == null )
                    continue;

                /*
                **  The EnvVar is a ; sep list of dirs
                **  Walk the list looking for a suitable DLL
                */
                foreach (string dir in Path.Split(';') )
                {
                    if (par.Verbose > 0 )
                        Console.WriteLine("   Path:" + dir);

                    if (File.Exists( dir + "\\" + Name ) )
                    {
                        if (par.Verbose > 0 )
                            Console.WriteLine("" + Name + " Found in: " + dir);
                        Assembly assembly = Assembly.LoadFrom(dir + "\\" + Name);
                        if ( assembly != null )
                        {
                            if (par.Verbose > 0 )
                                Console.WriteLine("" + Name + " Called: " + assembly.GetName());
                            if(String.Compare(assembly.GetName().FullName, args.Name) == 0)
                            {
                                return assembly;
                            }
                            
                            if (par.Verbose > 0 )
                            {
                                Console.WriteLine("Assembly Name Mismatch");
                                Console.WriteLine("   " + assembly.GetName().FullName);
                                Console.WriteLine("   " + args.Name);
                            }
                        }
                    }
                }
            }

            /*
            **  Not found
            **  Let the loader report the error
            */
            return null;
        }
    }
}