Project API

package com.tom.rv2ide.projects

import com.android.builder.model.v2.models.ProjectSyncIssues
import com.tom.rv2ide.tooling.api.IProject
import java.io.File

interface IProjectManager {
  
  // Properties
  val projectDir: File
  val projectDirPath: String
  val projectSyncIssues: ProjectSyncIssues?
  
  // Project operations
  fun openProject(directory: File)
  fun openProject(path: String)
  suspend fun setupProject(project: IProject)
  
  // Workspace access
  fun getWorkspace(): IWorkspace?
  fun requireWorkspace(): IWorkspace
  
  // File notifications
  fun notifyFileCreated(file: File)
  fun notifyFileDeleted(file: File)
  fun notifyFileRenamed(from: File, to: File)
  
  // Lifecycle
  fun destroy()
  
  companion object {
    fun getInstance(): IProjectManager
  }
}

package com.tom.rv2ide.projects

import com.android.builder.model.v2.models.ProjectSyncIssues
import com.tom.rv2ide.projects.android.AndroidModule
import com.tom.rv2ide.tooling.api.models.BuildVariantInfo
import java.io.File
import java.nio.file.Path

interface IWorkspace {
  
  // Project structure
  fun getProjectDir(): File
  fun getRootProject(): GradleProject
  fun getSubProjects(): List<GradleProject>
  fun getProjectSyncIssues(): ProjectSyncIssues
  
  // Build variants
  fun getAndroidVariantSelections(): Map<String, BuildVariantInfo>
  
  // Project queries
  fun findProject(path: String): GradleProject?
  fun getProject(path: String): GradleProject
  fun androidProjects(): Sequence<AndroidModule>
  
  // File queries
  fun findModuleForFile(file: Path, checkExistance: Boolean = false): ModuleProject?
  fun findModuleForFile(file: File, checkExistance: Boolean = false): ModuleProject?
  fun containsSourceFile(file: Path): Boolean
  fun isAndroidResource(file: File): Boolean
  
  class ProjectNotFoundException(path: String) : RuntimeException
  class NotConfiguredException : RuntimeException
}

import com.tom.rv2ide.projects.IProjectManager

val projectManager = IProjectManager.getInstance()
println("Project directory: ${projectManager.projectDir}")

import java.io.File

val projectDir = File("/storage/emulated/0/AndroidProjects/MyApp")
projectManager.openProject(projectDir)

// Or use path string
projectManager.openProject("/storage/emulated/0/AndroidProjects/MyApp")

val workspace = projectManager.getWorkspace()

if (workspace != null) {
  val rootProject = workspace.getRootProject()
  println("Root project: ${rootProject.name}")
} else {
  println("No workspace configured")
}

// Or require workspace (throws if not configured)
try {
  val workspace = projectManager.requireWorkspace()
  // Use workspace
} catch (e: IWorkspace.NotConfiguredException) {
  println("Workspace not ready yet")
}

val workspace = projectManager.requireWorkspace()

// Get root project
val rootProject = workspace.getRootProject()
println("Root: ${rootProject.name} at ${rootProject.projectDir}")

// Get all subprojects
val subprojects = workspace.getSubProjects()
subprojects.forEach { project ->
  println("  - ${project.path}: ${project.name}")
}

// Get only Android modules
val androidModules = workspace.androidProjects().toList()
androidModules.forEach { module ->
  println("Android module: ${module.name}")
  println("  Package: ${module.namespace}")
  println("  Min SDK: ${module.minSdk}")
}

// Find project (returns null if not found)
val appModule = workspace.findProject(":app")
if (appModule != null) {
  println("Found app module")
}

// Get project (throws if not found)
try {
  val libModule = workspace.getProject(":mylibrary")
  println("Library module: ${libModule.name}")
} catch (e: IWorkspace.ProjectNotFoundException) {
  println("Project not found: ${e.message}")
}

import java.nio.file.Paths

val filePath = Paths.get("/storage/emulated/0/MyApp/app/src/main/java/com/example/Main.kt")
val module = workspace.findModuleForFile(filePath)

if (module != null) {
  println("File belongs to module: ${module.name}")
  println("Module path: ${module.path}")
} else {
  println("File not part of any module")
}

import java.io.File

val javaFile = File("/path/to/MainActivity.java")
if (workspace.containsSourceFile(javaFile.toPath())) {
  println("This is a source file")
}

val layoutFile = File("/path/to/res/layout/activity_main.xml")
if (workspace.isAndroidResource(layoutFile)) {
  println("This is an Android resource file")
}

val variants = workspace.getAndroidVariantSelections()

variants.forEach { (projectPath, variantInfo) ->
  println("Project: $projectPath")
  println("  Build type: ${variantInfo.buildType}")
  println("  Flavors: ${variantInfo.flavors}")
}

val syncIssues = projectManager.projectSyncIssues

if (syncIssues != null) {
  println("Project sync issues found:")
  syncIssues.syncIssues.forEach { issue ->
    println("  [${issue.severity}] ${issue.message}")
    println("     at ${issue.data}")
  }
}

// Or from workspace
val workspaceSyncIssues = workspace.getProjectSyncIssues()

import java.io.File

// File created
val newFile = File("/path/to/NewClass.java")
projectManager.notifyFileCreated(newFile)

// File deleted
val deletedFile = File("/path/to/OldClass.java")
projectManager.notifyFileDeleted(deletedFile)

// File renamed or moved
val oldPath = File("/path/to/OldName.java")
val newPath = File("/path/to/NewName.java")
projectManager.notifyFileRenamed(oldPath, newPath)

interface GradleProject {
  val name: String
  val path: String  // e.g., ":app"
  val projectDir: File
  val buildDir: File
  val buildFile: File  // build.gradle or build.gradle.kts
}

abstract class ModuleProject : GradleProject {
  abstract val classPaths: Set<File>
  abstract val compileClasspaths: Set<File>
  abstract val compileSourceDirectories: Set<File>
  // More properties...
}

class AndroidModule : ModuleProject {
  val namespace: String
  val minSdk: Int
  val targetSdk: Int
  val compileSdk: String
  val resourceDirectories: Set<File>
  val assetsDirectories: Set<File>
  // More Android-specific properties...
}

import com.tom.rv2ide.projects.IProjectManager
import java.io.File
import java.nio.file.Paths

class ProjectAnalyzer {
  
  fun analyzeProject(projectPath: String) {
    val projectManager = IProjectManager.getInstance()
    
    // Open project
    projectManager.openProject(projectPath)
    
    // Wait for initialization (in real code, use proper async handling)
    val workspace = projectManager.requireWorkspace()
    
    // Analyze structure
    println("=== Project Structure ===")
    val root = workspace.getRootProject()
    println("Root: ${root.name}")
    
    workspace.getSubProjects().forEach { project ->
      println("\nModule: ${project.name} (${project.path})")
      println("  Location: ${project.projectDir}")
      println("  Build file: ${project.buildFile}")
    }
    
    // Analyze Android modules
    println("\n=== Android Modules ===")
    workspace.androidProjects().forEach { android ->
      println("${android.name}:")
      println("  Package: ${android.namespace}")
      println("  Min SDK: ${android.minSdk}")
      println("  Target SDK: ${android.targetSdk}")
      println("  Compile SDK: ${android.compileSdk}")
    }
    
    // Check variants
    println("\n=== Build Variants ===")
    workspace.getAndroidVariantSelections().forEach { (path, variant) ->
      println("$path: ${variant.buildType}")
    }
    
    // Find module for a file
    val testFile = Paths.get("$projectPath/app/src/main/java/MainActivity.kt")
    val module = workspace.findModuleForFile(testFile)
    if (module != null) {
      println("\nMainActivity.kt belongs to: ${module.name}")
    }
    
    // Check sync issues
    val issues = projectManager.projectSyncIssues
    if (issues != null && issues.syncIssues.isNotEmpty()) {
      println("\n=== Sync Issues ===")
      issues.syncIssues.forEach { issue ->
        println("[${issue.severity}] ${issue.message}")
      }
    } else {
      println("\nNo sync issues found")
    }
  }
}

// Clean up resources
projectManager.destroy()