// Java way - verbose and error-prone
val configPath = Paths.get("config").resolve("app.conf")
if (Files.exists(configPath)) {
  val content = new String(Files.readAllBytes(configPath), StandardCharsets.UTF_8)
}

// Path way - clean and fluent
val configPath = Path("config") / "app.conf"
if (configPath.exists) {
  val content = configPath.readText()
}

import io.github.edadma.path._

// Create paths naturally
val projectDir = Path("src") / "main" / "scala"
val configFile = Path("/etc") / "myapp" / "config.json"

// File operations as methods (the way it should be!)
if (configFile.exists) {
  val config = configFile.readText()
  println(s"Config: $config")
}

// Rich path manipulation
val scalaFile = Path("MyClass.scala")
println(s"Extension: ${scalaFile.extension}")           // .scala
println(s"Name: ${scalaFile.nameWithoutExtension}")     // MyClass
val javaFile = scalaFile.withExtension("java")          // MyClass.java

// Convert to absolute paths
val absolutePath = projectDir.toAbsolutePath
println(s"Absolute: $absolutePath")

// Create directory structure
val buildDir = Path("target") / "classes"
buildDir.createDirectories()

// List files with patterns
val scalaFiles = projectDir.listDirectory("*.scala")
scalaFiles.foreach { entry =>
  println(s"Found: ${entry.name}")
}

// Check file permissions and metadata
if (configFile.isReadable && !configFile.isEmpty) {
  println("Config file is readable and not empty")
}

// Path construction and combination
val base = Path("/home/user")
val docs = base / "documents" / "projects"

// Rich path manipulation
val sourceFile = Path("/projects/myapp/src/main/scala/MyClass.scala")

// File extensions
println(sourceFile.extension)              // .scala
println(sourceFile.nameWithoutExtension)   // MyClass
val testFile = sourceFile.withExtension("test.scala")  // MyClass.test.scala

// Path segments and subpaths
println(sourceFile.subpath(2, 5))          // src/main/scala
println(sourceFile.startsWith(Path("/projects")))  // true
println(sourceFile.endsWith(Path("MyClass.scala"))) // true

// Convert relative to absolute
val relPath = Path("src/main/scala")
val absPath = relPath.toAbsolutePath     // /current/working/dir/src/main/scala

// Relative paths between locations
val targetDir = Path("/home/user/projects/myapp/target")
val relative = targetDir.relativeTo(base)  // projects/myapp/target

// Path normalization
val messy = Path("src/../config/./app.conf")
val clean = messy.normalize                 // config/app.conf

// Parent and filename
val file = Path("/home/user/document.pdf")
println(file.parent)    // Some(/home/user)
println(file.filename)  // document.pdf

val file = Path("important-document.pdf")

// Existence and type checking
println(s"Exists: ${file.exists}")
println(s"Is file: ${file.isFile}")
println(s"Is directory: ${file.isDirectory}")
println(s"Is symbolic link: ${file.isSymbolicLink}")

// Permission checking
println(s"Readable: ${file.isReadable}")
println(s"Writable: ${file.isWritable}")
println(s"Executable: ${file.isExecutable}")

// File properties
println(s"Size: ${file.size} bytes")
println(s"Modified: ${file.lastModified}")
println(s"Empty: ${file.isEmpty}")

// Compare files
val backup = Path("document-backup.pdf")
if (file.isSameFile(backup)) {
  println("Files are identical (same inode/reference)")
}

val file = Path("data.txt")

// Text files
file.writeText("Hello, World!")
val content = file.readText()

// Binary files  
val data = Array[Byte](1, 2, 3, 4)
file.writeBytes(data)
val bytes = file.readBytes

// Check if file/directory is empty
if (file.isEmpty) {
  println("File has no content")
}

val dir = Path("build")

// Create directories
dir.createDirectories()  // Creates parents too

// List contents with filtering
val allFiles = dir.listDirectory()
val jsonFiles = dir.listDirectory("*.json")
val appFiles = dir.listDirectory("app*")

allFiles.foreach { entry =>
  val typeStr = entry.fileType match {
    case FileType.File => "FILE"
    case FileType.Directory => "DIR"
    case FileType.SymbolicLink => "LINK"
    case FileType.Other => "OTHER"
  }
  println(s"$typeStr: ${entry.name}")
}

// Check if directory is empty
if (dir.isEmpty) {
  println("Directory contains no files")
}

val source = Path("document.pdf")
val backup = Path("backup") / "document.pdf"
val archive = Path("archive") / "document.pdf"

// Copy and move operations
source.copyTo(backup)    // Copy to backup location
source.moveTo(archive)   // Move to archive

// Cleanup
backup.delete()

// Handle various file types
val files = Vector(
  Path("README.md"),
  Path("app.conf"),
  Path("data.json"),
  Path("script.sh"),
  Path("archive.tar.gz")
)

files.foreach { file =>
  println(s"File: ${file.filename}")
  println(s"  Extension: '${file.extension}'")
  println(s"  Without ext: '${file.nameWithoutExtension}'")
  println(s"  As backup: ${file.withExtension(file.extension + ".bak")}")
  println()
}

val projectRoot = Path("/projects/myapp")
val sourceDir = projectRoot / "src" / "main" / "scala"
val testDir = projectRoot / "src" / "test" / "scala"

// Check relationships
println(sourceDir.startsWith(projectRoot))  // true
println(sourceDir.endsWith(Path("scala")))  // true

// Get relative paths between directories
val relativeToTest = sourceDir.relativeTo(testDir)
println(relativeToTest)  // ../../main/scala

// Extract specific path segments
val pathSegments = sourceDir.subpath(1, 4)  // projects/myapp/src

def analyzeDirectory(dir: Path): Unit = {
  if (!dir.exists || !dir.isDirectory) {
    println(s"$dir is not a valid directory")
    return
  }
  
  val entries = dir.listDirectory()
  val (files, dirs, links) = entries.partition(_.fileType).fold(
    (Vector.empty, Vector.empty, Vector.empty)
  ) { case ((f, d, l), entry) =>
    entry.fileType match {
      case FileType.File => (f :+ entry, d, l)
      case FileType.Directory => (f, d :+ entry, l)
      case FileType.SymbolicLink => (f, d, l :+ entry)
      case FileType.Other => (f, d, l)
    }
  }
  
  println(s"Analysis of $dir:")
  println(s"  Files: ${files.length}")
  println(s"  Directories: ${dirs.length}")
  println(s"  Symbolic links: ${links.length}")
  println(s"  Empty: ${dir.isEmpty}")
  
  // Find largest files
  val fileSizes = files.map { entry =>
    val filePath = dir / entry.name
    (entry.name, filePath.size)
  }.sortBy(-_._2)
  
  println("  Largest files:")
  fileSizes.take(3).foreach { case (name, size) =>
    println(s"    $name: $size bytes")
  }
}

libraryDependencies += "io.github.edadma" %% "path" % "0.0.2"

// shared/src/main/scala - your cross-platform code using Path
// jvm/src/main/scala    - JVM-specific implementations  
// js/src/main/scala     - JS-specific implementations
// native/src/main/scala - Native-specific implementations

val configDir = Path(System.getProperty("user.home")) / ".myapp"
configDir.createDirectories()

val configFile = configDir / "config.json"
if (!configFile.exists) {
  configFile.writeText("""{"theme": "dark", "autoSave": true}""")
}

// Validate config file
if (configFile.isReadable && !configFile.isEmpty) {
  val config = configFile.readText()
  println(s"Loaded config: ${config.length} characters")
}

val sourceDir = Path("src") / "main" / "scala"
val targetDir = Path("target") / "classes"

// Find all Scala source files
val scalaFiles = sourceDir.listDirectory("*.scala")
println(s"Found ${scalaFiles.length} Scala files")

// Analyze source files
scalaFiles.foreach { entry =>
  val sourcePath = sourceDir / entry.name
  println(s"${sourcePath.filename}: ${sourcePath.size} bytes")
  
  // Convert to target path
  val targetPath = targetDir / sourcePath.nameWithoutExtension.withExtension("class")
  println(s"  → ${targetPath}")
}

// Compile to target directory
targetDir.createDirectories()

val logDir = Path("logs")
logDir.createDirectories()

// Find and archive old logs
val logFiles = logDir.listDirectory("*.log")
val archiveDir = logDir / "archive"

if (logFiles.nonEmpty) {
  archiveDir.createDirectories()
  
  logFiles.foreach { entry =>
    val logFile = logDir / entry.name
    
    // Check if log file should be archived (e.g., older than 30 days)
    val ageMs = System.currentTimeMillis() - logFile.lastModified
    val ageDays = ageMs / (1000 * 60 * 60 * 24)
    
    if (ageDays > 30) {
      val archiveFile = archiveDir / entry.name
      println(s"Archiving ${logFile.filename} (${ageDays} days old)")
      logFile.moveTo(archiveFile)
    }
  }
}

// Clean up empty directories
if (logDir.isEmpty) {
  println("Log directory is empty")
}

def findLargestFiles(dir: Path, count: Int = 10): Vector[(Path, Long)] = {
  if (!dir.exists || !dir.isDirectory) {
    return Vector.empty
  }
  
  val allFiles = dir.listDirectory()
    .filter(_.fileType == FileType.File)
    .map(entry => dir / entry.name)
    .filter(_.isReadable)
  
  allFiles
    .map(file => (file, file.size))
    .sortBy(-_._2)
    .take(count)
}

def findFilesByExtension(dir: Path, extension: String): Vector[Path] = {
  val pattern = if (extension.startsWith(".")) s"*$extension" else s"*.$extension"
  
  dir.listDirectory(pattern)
    .map(entry => dir / entry.name)
    .filter(_.isFile)
}

// Usage
val projectDir = Path(".")
val largestFiles = findLargestFiles(projectDir)
val scalaFiles = findFilesByExtension(projectDir, ".scala")

println("Largest files:")
largestFiles.foreach { case (file, size) =>
  println(s"  ${file.filename}: $size bytes")
}

println(s"\nFound ${scalaFiles.length} Scala files")