using System;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace MsBuild.TiDesktop
{
    /// <summary>
    ///
    /// </summary>
    public class BuildTask : Task
    {
        /// <summary>
        /// To load the dll - <paramref name="dllFilePath"/> doesn't have to be
        /// constant - so I can read path from registry
        /// </summary>
        /// <param name="dllFilePath">file path with file name</param>
        /// <param name="hFile">use <see cref="IntPtr.Zero"/></param>
        /// <param name="dwFlags">What will happened during loading dll
        /// <para>LOAD_LIBRARY_AS_DATAFILE</para>
        /// <para>DONT_RESOLVE_DLL_REFERENCES</para>
        /// <para>LOAD_WITH_ALTERED_SEARCH_PATH</para>
        /// <para>LOAD_IGNORE_CODE_AUTHZ_LEVEL</para>
        /// </param>
        /// <returns>Pointer to loaded Dll</returns>
        [DllImport("KERNEL32.DLL")]
        private static extern IntPtr LoadLibraryEx(string dllFilePath, IntPtr hFile, uint dwFlags);

        /// <summary>
        /// To unload library
        /// </summary>
        /// <param name="dllPointer">Pointer to Dll witch was returned from <see cref="LoadLibraryEx"/></param>
        /// <returns>If unloaded library was correct then <see langword="true"/>, else <see langword="false"/></returns>
        [DllImport("KERNEL32.DLL")]
        public static extern bool FreeLibrary(IntPtr dllPointer);

        /// <summary>
        /// To get function pointer from loaded dll
        /// </summary>
        /// <param name="dllPointer">Pointer to Dll witch was returned from <see cref="LoadLibraryEx"/></param>
        /// <param name="functionName">Function name with you want to call</param>
        /// <returns>Pointer to function</returns>
        [DllImport("KERNEL32.DLL")]
        public static extern IntPtr GetProcAddress(IntPtr dllPointer, string functionName);

        /// <summary>
        /// This will to load concrete dll file
        /// </summary>
        /// <param name="dllFilePath">Dll file path</param>
        /// <returns>Pointer to loaded dll</returns>
        /// <exception cref="ApplicationException">
        /// when loading dll will failure
        /// </exception>
        public static IntPtr LoadWin32Library(string dllFilePath)
        {
            IntPtr moduleHandle = LoadLibraryEx(dllFilePath, IntPtr.Zero, 0x00000008);
            if (moduleHandle == IntPtr.Zero) {
                // I'm gettin last dll error
                int errorCode = Marshal.GetLastWin32Error();
                throw new ApplicationException(
                    string.Format("There was an error during dll loading : {0}, error - {1}", dllFilePath, errorCode)
                    );
            }
            return moduleHandle;
        }

        // **************************************************************************************************************************
        // That is all, now how to use this functions
        // **************************************************************************************************************************

        /// <summary>
        ///
        /// </summary>
        /// <exception cref="ApplicationException"></exception>
        public static void InitializeMyDll(string pathDLL, out IntPtr myDll)
        {
            try {
                myDll = LoadWin32Library(pathDLL);
            }
            catch (ApplicationException) {
                myDll = IntPtr.Zero;
                throw;
            }
        }

        // The last thing is to create delegate to calling function

        // delegate must to have the same parameter then calling function (from dll)
        /// <summary>
        ///
        /// </summary>
        /// <param name="argc"></param>
        /// <param name="argv"></param>
        [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        public delegate int Py_Main(int argc, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPStr, SizeConst = 9)] string[] argv);

        /// <summary>
        ///
        /// </summary>
        /// <param name="pyPath"></param>
        /// <param name="argc"></param>
        /// <param name="argv"></param>
        /// <returns></returns>
        public static int PyMain(string pyPath, int argc, string[] argv)
        {
            IntPtr myDll;
            InitializeMyDll(pyPath, out myDll);
            if(myDll == IntPtr.Zero) {
                return 3;
            }

            IntPtr pProc = GetProcAddress(myDll, @"Py_Main");
            Delegate dPyMain = null;


            try {
                dPyMain = Marshal.GetDelegateForFunctionPointer(pProc, typeof(Py_Main));
            } catch (ArgumentException e) {
                Console.WriteLine(e.ParamName);
                Console.WriteLine(e.Message);
                Console.WriteLine(e);
            }
            if (dPyMain != null) {
                int _result = (int)(dPyMain.DynamicInvoke(argc, argv));
                FreeLibrary(myDll);
                return _result;
            }

            return 3;
        }

        // Now if you want to call dll function from program code use this
        // for ex. you want to call c++ function RETURN_TYPE CallingFunctionNameFromCallingDllFile(int nID, LPSTR lpstrName);

        /// <summary>
        /// Executes a task.
        /// </summary>
        /// <returns>
        /// <see langword="true"/> if the task executed successfully; otherwise, <see langword="false"/>.
        /// </returns>
        public override bool Execute()
        {
            const string sdkVersion = "1.1.0";

            Log.LogMessage(MessageImportance.High, "Locating path to Titanium SDK.");
            string pathProgData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData); // Environment.GetEnvironmentVariable(@"ProgramData");
            if(string.IsNullOrEmpty(pathProgData)) {
                Log.LogErrorFromException(new DirectoryNotFoundException("ProgramData couldn't be resolved."));
                return false;
            }

            Log.LogMessage(MessageImportance.Low, String.Format("Checking if Titanium folder exists in {0}..", pathProgData));
            pathProgData = Path.Combine(pathProgData, "Titanium");
            if ((!Directory.Exists(pathProgData)) || (Directory.GetFileSystemEntries(pathProgData).Length < 1)) {
                Log.LogErrorFromException(new DirectoryNotFoundException("Directory \"" + pathProgData + "\" does not exist."));
                return false;
            }

            // Resolve the paths.
            Log.LogMessage(MessageImportance.Normal, "Verifying existence of Titanium's python distribution and build script.");
            string pathPython = String.Format("{0}{1}modules{1}win32{1}python{1}{2}", pathProgData, Path.DirectorySeparatorChar, sdkVersion);
            string pathBuildSDK = String.Format("{0}{1}sdk{1}win32{1}{2}", pathProgData, Path.DirectorySeparatorChar, sdkVersion);
            string pathBuildScript = String.Format("{0}{1}tibuild.py", pathBuildSDK, Path.DirectorySeparatorChar);
            string pathPyDll = Path.Combine(pathPython, "python25.dll");
            string pathPyLib = String.Format("{0}{1}{0}{2}Lib{1}{0}{2}tcl{1}{0}{2}DLLs", pathPython, Path.PathSeparator, Path.DirectorySeparatorChar);
            string pathPyBin = String.Format("{0}{1}{0}{2}Lib{2}Tools{2}Scripts", pathPython, Path.PathSeparator, Path.DirectorySeparatorChar);
            if(!File.Exists(pathBuildScript)||!File.Exists(pathPyDll)) {
                Log.LogErrorFromException(new FileNotFoundException("Could not find tibuild.py. (or could not find interpreter to run it)"));
                Log.LogMessage(MessageImportance.High, "Verify they exist as \n{0}\nand\n{1}", pathPyDll, pathBuildScript);
                return false;
            }
            Environment.SetEnvironmentVariable("PATH", pathPyBin, EnvironmentVariableTarget.Process);
            Environment.SetEnvironmentVariable("PYTHONPATH", pathPyLib, EnvironmentVariableTarget.Process);
            Environment.SetEnvironmentVariable("PYTHONDEBUG", "1", EnvironmentVariableTarget.Process);

            // Temporary
            string dest = Destination.ItemSpec;
            string src = Source.ItemSpec;
            String[] args = {
                                "python",
                                pathBuildScript,
                                "-d", dest,
                                "-s", String.Format("{0}{1}", pathProgData, Path.DirectorySeparatorChar),
                                "-a", pathBuildSDK,
                                src
                            };

            if (PyMain(pathPyDll, 9, args) != 0) {
                _results = "Your Titanium build has failed.";
                Log.LogMessage(MessageImportance.High, _results);
                return false;
            }
            _results = "Your Titanium build has succeeded!";
            return true;
        }

        /// <summary>
        ///
        /// </summary>
        [Required]
        public ITaskItem Source
        {
            get { return _sourceFolder; }
            set { _sourceFolder = value ?? _sourceFolder; }
        }

        /// <summary>
        ///
        /// </summary>
        [Required]
        public ITaskItem Destination
        {
            get { return _destFolder; }
            set { _destFolder = value ?? _destFolder; }
        }

        /// <summary>
        ///
        /// </summary>
        [Output]
        public string Results
        {
            get { return !string.IsNullOrEmpty(_results) ? _results : "Failed"; }
        }

        private string _results;
        private ITaskItem _sourceFolder;
        private ITaskItem _destFolder;

        /// <summary>
        ///
        /// </summary>
        public BuildTask()
        {
            _results = String.Empty;
        }
    }


}