/// <summary>
 /// Prints messages to the package manager output window
 /// </summary>
 /// <param name="message">Message to print</param>
 /// <param name="pane">Pane object</param>
 public static void PrintOutput(string message, IVsOutputWindowPane pane)
 {
     if(pane != null)
     {
         ErrorHandler.ThrowOnFailure(pane.OutputString(message + "\n"));
     }
 }

 public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs, IVsOutputWindowPane outputPane)
 {
     _repository = repo;
     _manager = manager;
     _mcs = mcs;
     _outputPane = outputPane;
 }

        public OutputWindowWriter(DTE dte, IVsOutputWindowPane outputWindow)
        {
            _outputWindow = outputWindow;
            _dte = dte;

            _outputWindow.Clear();
        }

 public int GetPane(ref Guid rguidPane, out IVsOutputWindowPane ppPane)
 {
     GetPaneCalled = true;
     GetPaneArgumentGuidPane = rguidPane;
     ppPane = GetPaneReturnValue;
     return VSConstants.S_OK;
 }

 public MSBuildRunner(IServiceProvider host, string msbuild, string projectName, string buildFullFileName, IVsOutputWindowPane buildWnd)
 {
     Host = host;
     BuildFullFileName = buildFullFileName;
     MSBUILD = msbuild;
     ProjectName = projectName;
     BuildWindow = buildWnd; // host.GetOutputPane(VSConstants.BuildOutput, "Build");
 }

 public Compiler(EnvDTE.Project proj, string file, IVsOutputWindowPane pane)
 {
     taskTimer = new TaskTimer("Compile " + file);
     project = proj;
     clTool = new VCCompilerHelper(project);
     filename = file;
     buildPane = pane;
 }

 /// <summary>
 /// Creates a new node provider
 /// </summary>
 /// <param name="parser"></param>
 /// <param name="buffer">buffer to watch</param>
 public NodeProvider(IVsOutputWindowPane djangoDiagnostics, IParser parser, ITextBuffer buffer)
 {
     this.djangoDiagnostics = djangoDiagnostics;
     this.parser = parser;
     this.buffer = buffer;
     filePath = ((ITextDocument)buffer.Properties[typeof(ITextDocument)]).FilePath;
     rebuildNodes(buffer.CurrentSnapshot);
     buffer.Changed += new EventHandler<TextContentChangedEventArgs>(buffer_Changed);
 }

 public static void Instantiate(IVsOutputWindowPane outputLog, IVsStatusbar statusBar)
 {
     lock (_locker)
     {
         if (_instance != null)
             throw new InvalidOperationException(string.Format("{0} of Resurrect is already instantiated.", _instance.GetType().Name));
         _instance = new Log(outputLog, statusBar);
     }
 }

 public int GetPane(ref Guid rguidPane, out IVsOutputWindowPane ppPane) {
     MockOutputWindowPane pane;
     if (_panes.TryGetValue(rguidPane, out pane)) {
         ppPane = pane;
         return VSConstants.S_OK;
     }
     ppPane = null;
     return VSConstants.E_FAIL;
 }

        public override MSBuildResult Build(uint vsopts, string config, IVsOutputWindowPane output, string target)
        {
            if (output != null)
            {
                output.OutputString("Build for node.js project is not required.\n");
            }

            return MSBuildResult.Successful;
        }

        public void UpdatePackage(string projPath, IVsOutputWindowPane pane, string platform)
        {
            Dictionary<string, string> patchMap = new Dictionary<string, string>();

            patchMap.Add(string.Format(CultureInfo.CurrentCulture, "\\uwp\\{0}\\serialport.node", platform),
                "\\node_modules\\serialport\\build\\serialport.node");

            NpmPatcher npmPatcher = new NpmPatcher();
            npmPatcher.UpdatePackage(new Uri(PatchUri), projPath, pane, Name, patchMap);
        }

		public int GetPane(ref Guid rguidPane, out IVsOutputWindowPane ppPane)
		{
			// First make sure the pane was created (we may need to add standard ones in the constructor)
			if (!paneList.ContainsKey(rguidPane))
				throw new ArgumentException("Could not find the requested pane, make sure you call CreatePane first");

			// Create a pane with the correct name
			ppPane = new OutputWindowPane(paneList[rguidPane]);
			return VSConstants.S_OK;
		}

        public MSBuildRunner(IServiceProvider host, string msbuild, string projectName, string buildFullFileName, IVsOutputWindowPane buildWnd)
        {
            Host = host;
            BuildFullFileName = buildFullFileName;
            MSBUILD = msbuild;
            ProjectName = projectName;
            BuildWindow = buildWnd;

            _pipename = string.Format(@"_sharponly_{0}", buildFullFileName.GetHashCode().ToString());
        }

 public void OutputString(string message)
 {
     string title = Resource.ToolWindowTitle;
     if (_outputPane == null)
     {
     _outputPane = (IVsOutputWindowPane)Package.GetGlobalService(typeof(SVsGeneralOutputWindowPane));
     }
     _outputPane.SetName(title);
     _outputPane.OutputStringThreadSafe(message + "\n");
 }

        int IVsOutputWindow.GetPane(ref Guid rguidPane, out IVsOutputWindowPane ppPane)
        {
            if (this.panes.ContainsKey(rguidPane))
            {
                ppPane = this.panes[rguidPane];
                return VSConstants.S_OK;
            }

            ppPane = null;
            return VSConstants.E_FAIL;
        }

 public BuildProfiler(EnvDTE.Project proj, int stackMaxSize, IVsOutputWindowPane bpane, IVsOutputWindowPane ppane, Action onFinished, string singleFile = null)
 {
     if (singleFile != null)
         onlyFile = singleFile;
     project = proj;
     clTool = new VCCompilerHelper(project);
     profilePane = ppane;
     buildPane = bpane;
     profiler = new ActiveObject(stackMaxSize);
     signalFinished = onFinished;
     Initialize();
     profiler.Signal();
 }

        /// <summary>
        /// Creates a new node provider
        /// </summary>
        /// <param name="parser"></param>
        /// <param name="buffer">buffer to watch</param>
        public NodeProvider(IVsOutputWindowPane djangoDiagnostics, IParser parser, ITextBuffer buffer)
        {
            this.djangoDiagnostics = djangoDiagnostics;
            this.parser = parser;
            this.buffer = buffer;
            filePath = ((ITextDocument)buffer.Properties[typeof(ITextDocument)]).FilePath;

            buffer.Changed += new EventHandler<TextContentChangedEventArgs>(buffer_Changed);
            // we need to run rebuildNodes on a separate thread. Using timer
            // for this seems to be an overkill, but we need the timer anyway so - why not
            parserTimer =
                new Timer(rebuildNodes, buffer.CurrentSnapshot, 0, Timeout.Infinite);
        }

        /// <summary>
        /// Constructor.  Inititialize member data.
        /// </summary>
        public IDEBuildLogger(IVsOutputWindowPane output, TaskProvider taskProvider, IVsHierarchy hierarchy)
        {
            if (taskProvider == null)
                throw new ArgumentNullException("taskProvider");
            if (hierarchy == null)
                throw new ArgumentNullException("hierarchy");

            this.taskProvider = taskProvider;
            this.outputWindowPane = output;
            this.hierarchy = hierarchy;
            IOleServiceProvider site;
            Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(hierarchy.GetSite(out site));
            this.serviceProvider = new ServiceProvider(site);
        }

        public void UpdatePackage(string projPath, IVsOutputWindowPane pane)
        {
            Dictionary<string, string> patchMap = new Dictionary<string, string>();

            patchMap.Add("\\uwp\\serialport.js", "\\node_modules\\serialport\\serialport.js");
            foreach (Platform platform in Enum.GetValues(typeof(Platform)))
            {
                string platformStr = platform.ToString();
                patchMap.Add(string.Format(CultureInfo.CurrentCulture, "\\uwp\\{0}\\serialport.node", platformStr), string.Format(CultureInfo.CurrentCulture,
                    "\\node_modules\\serialport\\build\\Release\\node-{0}-win32-{1}\\serialport.node", NODE_MODULE_VERSION, (platform == Platform.x86) ? "ia32" : platformStr));      
            }

            NpmPatcher npmPatcher = new NpmPatcher();
            npmPatcher.UpdatePackage(new Uri(PatchUri), projPath, pane, Name, patchMap);
        }

        static Output()
        {
            const string customTitle = "EventStore";
            var outWindow = (IVsOutputWindow) Package.GetGlobalService(typeof (SVsOutputWindow));

            // Use e.g. Tools -> Create GUID to make a stable, but unique GUID for your pane.
            // Also, in a real project, this should probably be a static constant, and not a local variable
            var customGuid = new Guid(EventStoreOutputWindowGuid);
            outWindow.CreatePane(ref customGuid, customTitle, 1, 1);

            IVsOutputWindowPane customPane;
            outWindow.GetPane(ref customGuid, out customPane);

            Pane = customPane;
        }