MainWindow.Project.vb

' MainWindow.Project.vb - Project management implementation
Imports Gtk
Imports System
Imports System.IO
Imports SimpleIDE.Utilities
Imports SimpleIDE.Dialogs
Imports SimpleIDE.Managers
Imports SimpleIDE.Models

Partial Public Class MainWindow
    
    ' ===== Project Operations =====
    Public Sub OnNewProject(vSender As Object, vArgs As EventArgs)
        Try
            ' Close all open editors from the current project (prompts to save/discard, may cancel)
            If Not CloseAllTabs() Then Return

            ' Show new project dialog
            Dim lDialog As New NewProjectDialog(Me, pThemeManager)

            If lDialog.Run() = CInt(ResponseType.Ok) Then
                Dim lProjectPath As String = lDialog.ProjectPath
                Dim lProjectName As String = lDialog.ProjectName
                Dim lProjectType As String = lDialog.ProjectType

                ' Create project
                If CreateNewProject(lProjectPath, lProjectName, lProjectType) Then
                    ' Load the new project
                    Dim lProjectFile As String = System.IO.Path.Combine(lProjectPath, $"{lProjectName}.vbproj")
                    LoadProjectEnhanced(lProjectFile)
                    
                    ' Add to recent projects
                    pSettingsManager.AddRecentProject(lProjectFile)
                End If
            End If
            
            lDialog.Destroy()
            
        Catch ex As Exception
            Console.WriteLine($"OnNewProject error: {ex.Message}")
            ShowError("New project error", ex.Message)
        End Try
    End Sub
    
    Public Sub OnOpenProject(vSender As Object, vArgs As EventArgs)
        Try
            ' Close all open editors from the current project (prompts to save/discard, may cancel)
            If Not CloseAllTabs() Then Return

            Dim lDialog As FileChooserDialog = FileOperations.CreateOpenProjectDialog(Me)
            
            If lDialog.Run() = CInt(ResponseType.Accept) Then
                LoadProjectEnhanced(lDialog.FileName)
            End If
            
            lDialog.Destroy()
            
        Catch ex As Exception
            Console.WriteLine($"OnOpenProject error: {ex.Message}")
            ShowError("Open project error", ex.Message)
        End Try
    End Sub
    
    Private Function CreateNewProject(vProjectPath As String, vProjectName As String, vProjectType As String) As Boolean
        Try
            ' Create project directory
            If Not Directory.Exists(vProjectPath) Then
                Directory.CreateDirectory(vProjectPath)
            End If
            
            ' Create project file
            Dim lProjectFile As String = System.IO.Path.Combine(vProjectPath, $"{vProjectName}.vbproj")
            
            ' FIXED: Create parameters for VbProjTemplate
            Dim lOutputType As String = ""
            Dim lPackageReferences As String = ""
            
            Select Case vProjectType
                Case "Console"
                    lOutputType = "Exe"
                Case "Library"
                    lOutputType = "Library"
                Case Else 
                    lOutputType = "Exe"
                    lPackageReferences = StringResources.Instance.GetString("GtkPackageReference")
            End Select
            
            ' Explicit Compile items - EnableDefaultCompileItems is False in the template,
            ' so every source file we generate below must be listed here or it will be
            ' invisible to both SimpleIDE's ProjectFileParser and a real dotnet build
            Dim lCompileItems As String = "<Compile Include=""My project/AssemblyInfo.vb"" />" & Environment.NewLine &
                "    <Compile Include=""Program.vb"" />"

            Dim lProjectParams As New Dictionary(Of String, String) From {
                {"OutputType", lOutputType},
                {"RootNamespace", vProjectName},
                {"PackageReferences", lPackageReferences},
                {"CompileItems", lCompileItems}
            }
            
            Dim lProjectContent As String = StringResources.Instance.GetTemplate(StringResources.KEY_VBPROJ_TEMPLATE, lProjectParams)  
          
            File.WriteAllText(lProjectFile, lProjectContent)
            
            ' Create My Project directory
            Dim lMyProjectDir As String = System.IO.Path.Combine(vProjectPath, "My project")
            Directory.CreateDirectory(lMyProjectDir)
            
            ' Create AssemblyInfo.vb
            Dim lAssemblyInfoFile As String = System.IO.Path.Combine(lMyProjectDir, "AssemblyInfo.vb")

            ' FIXED: Create parameters for AssemblyInfoTemplate
            Dim lAssemblyParams As New Dictionary(Of String, String) From {
                {"ProjectName", vProjectName},
                {"Description", $"{vProjectName} application"},
                {"Company", ""},
                {"Year", DateTime.Now.Year.ToString()}
            }

            Dim lAssemblyInfoContent As String = StringResources.Instance.GetTemplate(StringResources.KEY_ASSEMBLYINFO_TEMPLATE, lAssemblyParams)

            File.WriteAllText(lAssemblyInfoFile, lAssemblyInfoContent)
            
            ' Create main program file
            Dim lProgramFile As String = System.IO.Path.Combine(vProjectPath, "Program.vb")
            Dim lProgramContent As String = ""
            
            Select Case vProjectType
                Case "Console"
                    ' FIXED: Create parameters for ConsoleProjectTemplate
                    Dim lConsoleParams As New Dictionary(Of String, String) From {
                        {"ProjectName", vProjectName}
                    }
                    lProgramContent = StringResources.Instance.GetTemplate(StringResources.KEY_CONSOLE_PROJECT_TEMPLATE, lConsoleParams)                
                Case "Library"
                    ' FIXED: Create parameters for LibraryProjectTemplate
                    Dim lLibraryParams As New Dictionary(Of String, String) From {
                        {"ProjectName", vProjectName},
                        {"ClassName", "Class1"}
                    }
                    lProgramContent = StringResources.Instance.GetTemplate(StringResources.KEY_LIBRARY_PROJECT_TEMPLATE, lLibraryParams)                
                Case Else 
                    ' FIXED: Create parameters for GtkProjectTemplate
                    Dim lGtkParams As New Dictionary(Of String, String) From {
                        {"ProjectName", vProjectName}
                    }
                    lProgramContent = StringResources.Instance.GetTemplate(StringResources.KEY_GTK_PROJECT_TEMPLATE, lGtkParams)                    
            End Select
            
            File.WriteAllText(lProgramFile, lProgramContent)
            
            Return True
            
        Catch ex As Exception
            Console.WriteLine($"CreateNewProject error: {ex.Message}")
            ShowError("Create project error", ex.Message)
            Return False
        End Try
    End Function
    
    ' ===== Project Management =====

    ''' <summary>
    ''' Handles the "Project -> Add New Item..." menu command
    ''' </summary>
    ''' <remarks>
    ''' Delegates to CustomDrawProjectExplorer.OnContextMenuAddNewItem (the same handler its
    ''' own right-click "Add New Item" context-menu entry uses) instead of maintaining a
    ''' separate implementation here. The old standalone implementation wrote the file
    ''' directly with File.WriteAllText and never called ProjectManager.AddFileToProject, so
    ''' the new file was never registered as a project source file; it then called
    ''' RefreshProject(), which - before that method was made solution-aware - unconditionally
    ''' rebuilt the tree via the single-project LoadProjectFromManager, discarding the
    ''' synthetic solution root and every sibling project's subtree whenever a .sln was
    ''' loaded (James: "It really messed up the project explorer"). The delegated-to
    ''' implementation avoids both problems and additionally offers the full item-type
    ''' selector (Class/Module/Interface/Form/etc.) instead of always creating a bare class.
    ''' </remarks>
    Public Sub OnAddNewItem(vSender As Object, vArgs As EventArgs)
        Try
            If pProjectExplorer Is Nothing OrElse String.IsNullOrEmpty(pCurrentProject) Then
                ShowInfo("No project", "Please open a project first.")
                Return
            End If

            pProjectExplorer.OnContextMenuAddNewItem(vSender, vArgs)

        Catch ex As Exception
            Console.WriteLine($"OnAddNewItem error: {ex.Message}")
            ShowError("Add item error", ex.Message)
        End Try
    End Sub
    
    Public Sub OnSaveProject(vSender As Object, vArgs As EventArgs)
        Try
            If String.IsNullOrEmpty(pCurrentProject) Then
                ShowInfo("No project", "Please open a project first.")
                Return
            End If
            
            ' Save all open files
            SaveAllFiles()

            ' NOTE: The .vbproj file itself doesn't need saving here - ProjectManager.
            ' SaveProjectFile already writes it immediately whenever a reference or item is
            ' added/removed (see ProjectManager.vb), so it's always already up to date on disk
            ShowInfo("Project Saved", "Project and all files have been saved.")
            
        Catch ex As Exception
            Console.WriteLine($"OnSaveProject error: {ex.Message}")
            ShowError("Save project error", ex.Message)
        End Try
    End Sub
    
    Public Sub OnCloseProject(vSender As Object, vArgs As EventArgs)
        Try
            ' Check for unsaved changes
            If Not CheckUnsavedChanges() Then
                Return
            End If
            
            ' Close project
            CloseCurrentProject()
            
            ShowInfo("Project Closed", "Project has been closed.")
            
        Catch ex As Exception
            Console.WriteLine($"OnCloseProject error: {ex.Message}")
            ShowError("Close project error", ex.Message)
        End Try
    End Sub
    
    ' ===== Helper Methods =====
    
    ''' <summary>
    ''' Checks all open documents for unsaved changes, prompting to save/discard/cancel for
    ''' each one that has any
    ''' </summary>
    ''' <returns>True if it's okay to proceed (nothing unsaved, or the user saved/discarded
    ''' everything); False if the user cancelled, meaning the caller should abort whatever
    ''' operation (opening a different project/file, etc.) prompted this check</returns>
    Private Function CheckUnsavedChanges() As Boolean
        Try
            for each lTabEntry in pOpenTabs
                Dim lTabInfo As TabInfo = lTabEntry.Value
                If Not lTabInfo.Modified Then Continue for

                Dim lResponse As ResponseType = ShowCustomButtonDialog(
                    MessageType.Question,
                    $"Save changes to {System.IO.Path.GetFileName(lTabInfo.FilePath)} before continuing?",
                    New String() {"Don't Save", "Cancel", "Save"},
                    New ResponseType() {ResponseType.No, ResponseType.Cancel, ResponseType.Yes})

                Select Case lResponse
                    Case ResponseType.Yes
                        If Not SaveFile(lTabInfo) Then Return False
                    Case ResponseType.Cancel
                        Return False
                    Case ResponseType.No
                        ' Discard changes - reverts the cached SourceFileInfo to match disk
                        DiscardTabChanges(lTabInfo)
                End Select
            Next

            Return True

        Catch ex As Exception
            Console.WriteLine($"CheckUnsavedChanges error: {ex.Message}")
            Return False
        End Try
    End Function
    
    ' Close the current project
    Private Sub CloseCurrentProject()
        Try
            ' Close all open documents - abort if the user cancels closing one
            If Not CloseAllTabs() Then Return

            ' Clear project explorer
            pProjectExplorer.ClearProject()
            
            ' Clear current project
            pCurrentProject = ""
            
            ' Update window title
            UpdateWindowTitle()
            
        Catch ex As Exception
            Console.WriteLine($"CloseCurrentProject error: {ex.Message}")
        End Try
    End Sub
    
    
    ''' <summary>
    ''' Updates the window title to show project, current file, and their modified states
    ''' </summary>
    Private Sub UpdateWindowTitle()
        Try
            Dim lTitle As String = ApplicationVersion.Title
            
            ' Add version in debug builds or if configured
            If pSettingsManager.ShowVersionInTitle OrElse System.Diagnostics.Debugger.IsAttached Then
                lTitle &= $" v{ApplicationVersion.VersionString}"
            End If
            
            ' Add project name if loaded
            If Not String.IsNullOrEmpty(pCurrentProject) Then
                Dim lProjectName As String = System.IO.Path.GetFileNameWithoutExtension(pCurrentProject)
                
                ' FIXED: Show project dirty state (asterisk if ANY file in project is modified)
                Dim lHasModifiedFiles As Boolean = HasModifiedFiles()
                If lHasModifiedFiles Then
                    lTitle &= $" - *{lProjectName}"
                Else
                    lTitle &= $" - {lProjectName}"
                End If
                
                ' Add project version if available
                Try
                    Dim lVersionManager As New AssemblyVersionManager(pCurrentProject, pSettingsManager)
                    Dim lProjectVersion As Version = lVersionManager.GetCurrentVersion()
                    If lProjectVersion IsNot Nothing AndAlso lProjectVersion.ToString() <> "1.0.0.0" Then
                        lTitle &= $" (v{lProjectVersion.Major}.{lProjectVersion.Minor}.{lProjectVersion.Build})"
                    End If
                Catch
                    ' Ignore project version errors
                End Try
            End If
            
            ' Add current file name and its modified state
            Dim lCurrentTabInfo As TabInfo = GetCurrentTabInfo()
            If lCurrentTabInfo IsNot Nothing AndAlso Not String.IsNullOrEmpty(lCurrentTabInfo.FilePath) Then
                Dim lFileName As String = System.IO.Path.GetFileName(lCurrentTabInfo.FilePath)
                
                ' Add separator between project and file
                lTitle &= " - "
                
                ' Add asterisk if current file is modified
                If lCurrentTabInfo.Modified Then
                    lTitle &= $"*{lFileName}"
                Else
                    lTitle &= lFileName
                End If
            End If
            
            Title = lTitle
            
        Catch ex As Exception
            Console.WriteLine($"UpdateWindowTitle error: {ex.Message}")
            Title = "SimpleIDE"
        End Try
    End Sub

    ' Add version info to status bar methods
    Private Sub UpdateStatusBarWithVersion()
        Try
            ' Show application version in status occasionally
            If pBuildStatusLabel IsNot Nothing Then
                pBuildStatusLabel.Text = $"IDE v{ApplicationVersion.VersionString}"
                pBuildStatusLabel.Visible = True
            End If
            
        Catch ex As Exception
            Console.WriteLine($"UpdateStatusBarWithVersion error: {ex.Message}")
        End Try
    End Sub
    
    ' Method to refresh version displays throughout the UI
    Public Sub RefreshVersionDisplays()
        Try
            ' Update window title
            UpdateWindowTitle()
            
            ' Update status bar
            UpdateStatusBarWithVersion()
            
            ' Clear application version cache to get fresh data
            ApplicationVersion.ClearCache()
            
            #If DEBUG Then
            Console.WriteLine($"Version displays refreshed - IDE: {ApplicationVersion.VersionString}")
            #End If
            
        Catch ex As Exception
            Console.WriteLine($"RefreshVersionDisplays error: {ex.Message}")
        End Try
    End Sub

End Class