import { BusEvent } from "@/bus/bus-event"

import z from "zod"

import { formatPatch, structuredPatch } from "diff"

import path from "path"

import fs from "fs"

import ignore from "ignore"

import { Log } from "../util/log"

import { Filesystem } from "../util/filesystem"

import { Instance } from "../project/instance"

import { Ripgrep } from "./ripgrep"

import fuzzysort from "fuzzysort"

import { Global } from "../global"

import { git } from "@/util/git"

import { Protected } from "./protected"

export namespace File {

const log = Log.create({ service: "file" })

export const Info = z

.object({

path: z.string(),

added: z.number().int(),

removed: z.number().int(),

status: z.enum(["added", "deleted", "modified"]),

})

.meta({

ref: "File",

})

export type Info = z.infer<typeof Info>

export const Node = z

.object({

name: z.string(),

path: z.string(),

absolute: z.string(),

type: z.enum(["file", "directory"]),

ignored: z.boolean(),

})

.meta({

ref: "FileNode",

})

export type Node = z.infer<typeof Node>

export const Content = z

.object({

type: z.enum(["text", "binary"]),

content: z.string(),

diff: z.string().optional(),

patch: z

.object({

oldFileName: z.string(),

newFileName: z.string(),

oldHeader: z.string().optional(),

newHeader: z.string().optional(),

hunks: z.array(

z.object({

oldStart: z.number(),

oldLines: z.number(),

newStart: z.number(),

newLines: z.number(),

lines: z.array(z.string()),

}),

),

index: z.string().optional(),

})

.optional(),

encoding: z.literal("base64").optional(),

mimeType: z.string().optional(),

})

.meta({

ref: "FileContent",

})

export type Content = z.infer<typeof Content>

const binaryExtensions = new Set([

"exe",

"dll",

"pdb",

"bin",

"so",

"dylib",

"o",

"a",

"lib",

"wav",

"mp3",

"ogg",

"oga",

"ogv",

"ogx",

"flac",

"aac",

"wma",

"m4a",

"weba",

"mp4",

"avi",

"mov",

"wmv",

"flv",

"webm",

"mkv",

"zip",

"tar",

"gz",

"gzip",

"bz",

"bz2",

"bzip",

"bzip2",

"7z",

"rar",

"xz",

"lz",

"z",

"pdf",

"doc",

"docx",

"ppt",

"pptx",

"xls",

"xlsx",

"dmg",

"iso",

"img",

"vmdk",

"ttf",

"otf",

"woff",

"woff2",

"eot",

"sqlite",

"db",

"mdb",

"apk",

"ipa",

"aab",

"xapk",

"app",

"pkg",

"deb",

"rpm",

"snap",

"flatpak",

"appimage",

"msi",

"msp",

"jar",

"war",

"ear",

"class",

"kotlin_module",

"dex",

"vdex",

"odex",

"oat",

"art",

"wasm",

"wat",

"bc",

"ll",

"s",

"ko",

"sys",

"drv",

"efi",

"rom",

"com",

"cmd",

"ps1",

"sh",

"bash",

"zsh",

"fish",

])

const imageExtensions = new Set([

"png",

"jpg",

"jpeg",

"gif",

"bmp",

"webp",

"ico",

"tif",

"tiff",

"svg",

"svgz",

"avif",

"apng",

"jxl",

"heic",

"heif",

"raw",

"cr2",

"nef",

"arw",

"dng",

"orf",

"raf",

"pef",

"x3f",

])

const textExtensions = new Set([

"ts",

"tsx",

"mts",

"cts",

"mtsx",

"ctsx",

"js",

"jsx",

"mjs",

"cjs",

"sh",

"bash",

"zsh",

"fish",

"ps1",

"psm1",

"cmd",

"bat",

"json",

"jsonc",

"json5",

"yaml",

"yml",

"toml",

"md",

"mdx",

"txt",

"xml",

"html",

"htm",

"css",

"scss",

"sass",

"less",

"graphql",

"gql",

"sql",

"ini",

"cfg",

"conf",

"env",

])

const textNames = new Set([

"dockerfile",

"makefile",

".gitignore",

".gitattributes",

".editorconfig",

".npmrc",

".nvmrc",

".prettierrc",

".eslintrc",

])

function isImageByExtension(filepath: string): boolean {

const ext = path.extname(filepath).toLowerCase().slice(1)

return imageExtensions.has(ext)

}

function isTextByExtension(filepath: string): boolean {

const ext = path.extname(filepath).toLowerCase().slice(1)

return textExtensions.has(ext)

}

function isTextByName(filepath: string): boolean {

const name = path.basename(filepath).toLowerCase()

return textNames.has(name)

}

function getImageMimeType(filepath: string): string {

const ext = path.extname(filepath).toLowerCase().slice(1)

const mimeTypes: Record<string, string> = {

png: "image/png",

jpg: "image/jpeg",

jpeg: "image/jpeg",

gif: "image/gif",

bmp: "image/bmp",

webp: "image/webp",

ico: "image/x-icon",

tif: "image/tiff",

tiff: "image/tiff",

svg: "image/svg+xml",

svgz: "image/svg+xml",

avif: "image/avif",

apng: "image/apng",

jxl: "image/jxl",

heic: "image/heic",

heif: "image/heif",

}

return mimeTypes[ext] || "image/" + ext

}

function isBinaryByExtension(filepath: string): boolean {

const ext = path.extname(filepath).toLowerCase().slice(1)

return binaryExtensions.has(ext)

}

function isImage(mimeType: string): boolean {

return mimeType.startsWith("image/")

}

async function shouldEncode(mimeType: string): Promise<boolean> {

const type = mimeType.toLowerCase()

log.info("shouldEncode", { type })

if (!type) return false

if (type.startsWith("text/")) return false

if (type.includes("charset=")) return false

const parts = type.split("/", 2)

const top = parts[0]

const tops = ["image", "audio", "video", "font", "model", "multipart"]

if (tops.includes(top)) return true

return false

}

export const Event = {

Edited: BusEvent.define(

"file.edited",

z.object({

file: z.string(),

}),

),

}

const state = Instance.state(async () => {

type Entry = { files: string[]; dirs: string[] }

let cache: Entry = { files: [], dirs: [] }

let fetching = false

const isGlobalHome = Instance.directory === Global.Path.home && Instance.project.id === "global"

const fn = async (result: Entry) => {

// Disable scanning if in root of file system

if (Instance.directory === path.parse(Instance.directory).root) return

fetching = true

if (isGlobalHome) {

const dirs = new Set<string>()

const ignore = Protected.names()

const ignoreNested = new Set(["node_modules", "dist", "build", "target", "vendor"])

const shouldIgnore = (name: string) => name.startsWith(".") || ignore.has(name)

const shouldIgnoreNested = (name: string) => name.startsWith(".") || ignoreNested.has(name)

const top = await fs.promises

.readdir(Instance.directory, { withFileTypes: true })

.catch(() => [] as fs.Dirent[])

for (const entry of top) {

if (!entry.isDirectory()) continue

if (shouldIgnore(entry.name)) continue

dirs.add(entry.name + "/")

const base = path.join(Instance.directory, entry.name)

const children = await fs.promises.readdir(base, { withFileTypes: true }).catch(() => [] as fs.Dirent[])

for (const child of children) {

if (!child.isDirectory()) continue

if (shouldIgnoreNested(child.name)) continue

dirs.add(entry.name + "/" + child.name + "/")

}

}

result.dirs = Array.from(dirs).toSorted()

cache = result

fetching = false

return

}

const set = new Set<string>()

for await (const file of Ripgrep.files({ cwd: Instance.directory })) {

result.files.push(file)

let current = file

while (true) {

const dir = path.dirname(current)

if (dir === ".") break

if (dir === current) break

current = dir

if (set.has(dir)) continue

set.add(dir)

result.dirs.push(dir + "/")

}

}

cache = result

fetching = false

}

fn(cache)

return {

async files() {

if (!fetching) {

fn({

files: [],

dirs: [],

})

}

return cache

},

}

})

export function init() {

state()

}

export async function status() {

const project = Instance.project

if (project.vcs !== "git") return []

const diffOutput = (

await git(["-c", "core.fsmonitor=false", "-c", "core.quotepath=false", "diff", "--numstat", "HEAD"], {

cwd: Instance.directory,

})

).text()

const changedFiles: Info[] = []

if (diffOutput.trim()) {

const lines = diffOutput.trim().split("\n")

for (const line of lines) {

const [added, removed, filepath] = line.split("\t")

changedFiles.push({

path: filepath,

added: added === "-" ? 0 : parseInt(added, 10),

removed: removed === "-" ? 0 : parseInt(removed, 10),

status: "modified",

})

}

}

const untrackedOutput = (

await git(

["-c", "core.fsmonitor=false", "-c", "core.quotepath=false", "ls-files", "--others", "--exclude-standard"],

{

cwd: Instance.directory,

},

)

).text()

if (untrackedOutput.trim()) {

const untrackedFiles = untrackedOutput.trim().split("\n")

for (const filepath of untrackedFiles) {

try {

const content = await Filesystem.readText(path.join(Instance.directory, filepath))

const lines = content.split("\n").length

changedFiles.push({

path: filepath,

added: lines,

removed: 0,

status: "added",

})

} catch {

continue

}

}

}

// Get deleted files

const deletedOutput = (

await git(

["-c", "core.fsmonitor=false", "-c", "core.quotepath=false", "diff", "--name-only", "--diff-filter=D", "HEAD"],

{

cwd: Instance.directory,

},

)

).text()

if (deletedOutput.trim()) {

const deletedFiles = deletedOutput.trim().split("\n")

for (const filepath of deletedFiles) {

changedFiles.push({

path: filepath,

added: 0,

removed: 0, // Could get original line count but would require another git command

status: "deleted",

})

}

}

return changedFiles.map((x) => {

const full = path.isAbsolute(x.path) ? x.path : path.join(Instance.directory, x.path)

return {

...x,

path: path.relative(Instance.directory, full),

}

})

}

export async function read(file: string): Promise<Content> {

using _ = log.time("read", { file })

const project = Instance.project

const full = path.join(Instance.directory, file)

// TODO: Filesystem.contains is lexical only - symlinks inside the project can escape.

// TODO: On Windows, cross-drive paths bypass this check. Consider realpath canonicalization.

if (!Instance.containsPath(full)) {

throw new Error(`Access denied: path escapes project directory`)

}

// Fast path: check extension before any filesystem operations

if (isImageByExtension(file)) {

if (await Filesystem.exists(full)) {

const buffer = await Filesystem.readBytes(full).catch(() => Buffer.from([]))

const content = buffer.toString("base64")

const mimeType = getImageMimeType(file)

return { type: "text", content, mimeType, encoding: "base64" }

}

return { type: "text", content: "" }

}

const text = isTextByExtension(file) || isTextByName(file)

if (isBinaryByExtension(file) && !text) {

return { type: "binary", content: "" }

}

if (!(await Filesystem.exists(full))) {

return { type: "text", content: "" }

}

const mimeType = Filesystem.mimeType(full)

const encode = text ? false : await shouldEncode(mimeType)

if (encode && !isImage(mimeType)) {

return { type: "binary", content: "", mimeType }

}

if (encode) {

const buffer = await Filesystem.readBytes(full).catch(() => Buffer.from([]))

const content = buffer.toString("base64")

return { type: "text", content, mimeType, encoding: "base64" }

}

const content = (await Filesystem.readText(full).catch(() => "")).trim()

if (project.vcs === "git") {

let diff = (await git(["-c", "core.fsmonitor=false", "diff", "--", file], { cwd: Instance.directory })).text()

if (!diff.trim()) {

diff = (

await git(["-c", "core.fsmonitor=false", "diff", "--staged", "--", file], { cwd: Instance.directory })

).text()

}

if (diff.trim()) {

const original = (await git(["show", `HEAD:${file}`], { cwd: Instance.directory })).text()

const patch = structuredPatch(file, file, original, content, "old", "new", {

context: Infinity,

ignoreWhitespace: true,

})

const diff = formatPatch(patch)

return { type: "text", content, patch, diff }

}

}

return { type: "text", content }

}

export async function list(dir?: string) {

const exclude = [".git", ".DS_Store"]

const project = Instance.project

let ignored = (_: string) => false

if (project.vcs === "git") {

const ig = ignore()

const gitignorePath = path.join(Instance.worktree, ".gitignore")

if (await Filesystem.exists(gitignorePath)) {

ig.add(await Filesystem.readText(gitignorePath))

}

const ignorePath = path.join(Instance.worktree, ".ignore")

if (await Filesystem.exists(ignorePath)) {

ig.add(await Filesystem.readText(ignorePath))

}

ignored = ig.ignores.bind(ig)

}

const resolved = dir ? path.join(Instance.directory, dir) : Instance.directory

// TODO: Filesystem.contains is lexical only - symlinks inside the project can escape.

// TODO: On Windows, cross-drive paths bypass this check. Consider realpath canonicalization.

if (!Instance.containsPath(resolved)) {

throw new Error(`Access denied: path escapes project directory`)

}

const nodes: Node[] = []

for (const entry of await fs.promises

.readdir(resolved, {

withFileTypes: true,

})

.catch(() => [])) {

if (exclude.includes(entry.name)) continue

const fullPath = path.join(resolved, entry.name)

const relativePath = path.relative(Instance.directory, fullPath)

const type = entry.isDirectory() ? "directory" : "file"

nodes.push({

name: entry.name,

path: relativePath,

absolute: fullPath,

type,

ignored: ignored(type === "directory" ? relativePath + "/" : relativePath),

})

}

return nodes.sort((a, b) => {

if (a.type !== b.type) {

return a.type === "directory" ? -1 : 1

}

return a.name.localeCompare(b.name)

})

}

export async function search(input: { query: string; limit?: number; dirs?: boolean; type?: "file" | "directory" }) {

const query = input.query.trim()

const limit = input.limit ?? 100

const kind = input.type ?? (input.dirs === false ? "file" : "all")

log.info("search", { query, kind })

const result = await state().then((x) => x.files())

const hidden = (item: string) => {

const normalized = item.replaceAll("\\", "/").replace(/\/+$/, "")

return normalized.split("/").some((p) => p.startsWith(".") && p.length > 1)

}

const preferHidden = query.startsWith(".") || query.includes("/.")

const sortHiddenLast = (items: string[]) => {

if (preferHidden) return items

const visible: string[] = []

const hiddenItems: string[] = []

for (const item of items) {

const isHidden = hidden(item)

if (isHidden) hiddenItems.push(item)

if (!isHidden) visible.push(item)

}

return [...visible, ...hiddenItems]

}

if (!query) {

if (kind === "file") return result.files.slice(0, limit)

return sortHiddenLast(result.dirs.toSorted()).slice(0, limit)

}

const items =

kind === "file" ? result.files : kind === "directory" ? result.dirs : [...result.files, ...result.dirs]

const searchLimit = kind === "directory" && !preferHidden ? limit * 20 : limit

const sorted = fuzzysort.go(query, items, { limit: searchLimit }).map((r) => r.target)

const output = kind === "directory" ? sortHiddenLast(sorted).slice(0, limit) : sorted

log.info("search", { query, kind, results: output.length })

return output

}

}