import ArgumentParser

import Foundation

import SyntaxSparrow

import SwiftSyntax

// MARK: - search subcommand (project-wide clip search)

struct SearchCommand: ParsableCommand {

static let configuration = CommandConfiguration(

commandName: "search",

abstract: "Find declarations matching a pattern across a directory"

)

@Argument(help: "Substring to match against signatures")

var pattern: String

@Argument(help: "Directory to scan (default: current directory)")

var directory: String = "."

@Flag(help: "Emit JSON")

var json: Bool = false

@Flag(help: "Copy the first match body to the system pasteboard")

var pboard: Bool = false

@Option(help: "Limit results (0 = unlimited)")

var limit: Int = 0

func run() throws {

let expanded = (directory as NSString).expandingTildeInPath

let swiftFiles = try collectSwiftFiles(in: expanded)

struct Match {

let file: String

let signature: String

let body: String

}

var matches: [Match] = []

outer: for path in swiftFiles {

guard let source = try? String(contentsOfFile: path, encoding: .utf8) else { continue }

let doc = SyntaxTree(viewMode: .fixedUp, sourceBuffer: source)

doc.collectChildren()

// Check structures and their members

for structure in doc.structures {

for v in structure.variables {

let sig = v.code()

if sig.localizedCaseInsensitiveContains(pattern) {

let body = String(source[source.indexRange(for: v.node) ?? source.startIndex..<source.startIndex])

matches.append(Match(file: path, signature: "\(structure.name).\(sig)", body: body))

if limit > 0 && matches.count >= limit { break outer }

}

}

for fn in structure.functions {

let sig = fn.code()

if sig.localizedCaseInsensitiveContains(pattern) {

let body = String(source[source.indexRange(for: fn.node) ?? source.startIndex..<source.startIndex])

matches.append(Match(file: path, signature: "\(structure.name).\(sig)", body: body))

if limit > 0 && matches.count >= limit { break outer }

}

}

}

// Top-level functions

for fn in doc.functions {

let sig = fn.code()

if sig.localizedCaseInsensitiveContains(pattern) {

let body = String(source[source.indexRange(for: fn.node) ?? source.startIndex..<source.startIndex])

matches.append(Match(file: path, signature: sig, body: body))

if limit > 0 && matches.count >= limit { break outer }

}

}

}

if matches.isEmpty {

fputs("No declarations matching '\(pattern)' found in \(expanded)\n", stderr)

throw ExitCode.failure

}

if json {

let out = matches.map { m -> [String: Any] in

["file": relativePath(m.file, base: expanded), "signature": m.signature]

}

if let data = try? JSONSerialization.data(withJSONObject: out, options: .prettyPrinted),

let str = String(data: data, encoding: .utf8) {

print(str)

}

return

}

// Plain output: file:signature

for m in matches {

print("\(relativePath(m.file, base: expanded)): \(m.signature)")

}

// Optionally copy first match body to pasteboard

if pboard, let first = matches.first {

let process = Process()

process.executableURL = URL(fileURLWithPath: "/usr/bin/pbcopy")

let pipe = Pipe()

process.standardInput = pipe

try process.run()

pipe.fileHandleForWriting.write(Data(first.body.utf8))

pipe.fileHandleForWriting.closeFile()

process.waitUntilExit()

fputs("copied '\(first.signature)' to pasteboard\n", stderr)

}

}

private func relativePath(_ path: String, base: String) -> String {

path.hasPrefix(base) ? String(path.dropFirst(base.count + 1)) : path

}

}

// Helper to get a node's source range as String.Index range

private extension String {

func indexRange(for node: some SyntaxProtocol) -> Range<Index>? {

indexRange(from: node.position, to: node.endPosition)

}

}