package findr

import "core:fmt"
import "core:os"
import "core:strings"
import "core:sync"
import "core:sys/linux"
import "core:thread"

FINDR_PARALLEL :: #config(FINDR_PARALLEL, false)
FINDR_THREADS  :: #config(FINDR_THREADS, 8)

RawEntry :: struct {
	name: string,
	type: linux.Dirent_Type,
}

walk :: proc(root: string, results: ^[dynamic]string) {
    when FINDR_PARALLEL {
        walk_parallel(root, results)
    } else {
        walk_dir_serial(root, results)
    }
}

read_dir_entries :: proc(dir_path: string, has_git: ^bool) -> [dynamic]RawEntry {
    entries := make([dynamic]RawEntry)

    cpath := strings.clone_to_cstring(dir_path)
    if cpath == nil do return entries

    fd, err := linux.open(cpath, {.DIRECTORY, .CLOEXEC})
    delete(cpath)
    if err != .NONE do return entries

    buf: [8192]u8
    has_git^ = false

    for {
        n, errno := linux.getdents(fd, buf[:])
        if n <= 0 || errno != .NONE do break

        offs := 0
        for d in linux.dirent_iterate_buf(buf[:n], &offs) {
            name := linux.dirent_name(d)
            if name == "." || name == ".." do continue

            if name == ".git" && d.type == .DIR {
                has_git^ = true
            }

            cloned := strings.clone(name)
            append(&entries, RawEntry{name = cloned, type = d.type})
        }
    }

    linux.close(fd)
    return entries
}

free_entries :: proc(entries: ^[dynamic]RawEntry) {
    for &entry in entries {
        delete(entry.name)
    }
    delete(entries^)
}

walk_dir_serial :: proc(dir_path: string, results: ^[dynamic]string) {
    has_git := false
    entries := read_dir_entries(dir_path, &has_git)
    defer free_entries(&entries)

    if has_git {
        gi := load_gitignore(dir_path)
        defer if gi != nil {
            destroy(gi)
            free(gi)
        }

        for entry in entries {
            if entry.name == ".git" do continue
            is_dir := entry.type == .DIR
            if gi != nil && is_ignored(gi, entry.name, is_dir) {
                if !is_dir {
                    full_path := join_path(dir_path, entry.name)
                    append(results, full_path)
                }
                continue
            }
            if is_dir {
                child_path := join_path(dir_path, entry.name)
                walk_dir_serial(child_path, results)
                delete(child_path)
            }
        }
    } else {
        for entry in entries {
            if entry.type == .DIR {
                child_path := join_path(dir_path, entry.name)
                walk_dir_serial(child_path, results)
                delete(child_path)
            }
        }
    }
}

load_gitignore :: proc(dir_path: string) -> ^Gitignore {
    gi_path := join_path(dir_path, ".gitignore")
    defer delete(gi_path)

    data, err := os.read_entire_file_from_path(gi_path, context.allocator)
    if err != nil do return nil

    gi := new(Gitignore)
    gi^ = parse(string(data))
    delete(data)
    return gi
}

join_path :: proc(parent, child: string) -> string {
    b: strings.Builder
    strings.builder_init(&b)
    defer strings.builder_destroy(&b)

    fmt.sbprintf(&b, "%s", parent)
    if len(parent) == 0 || parent[len(parent) - 1] != '/' {
        fmt.sbprintf(&b, "/")
    }
    fmt.sbprintf(&b, "%s", child)

    s := strings.to_string(b)
    result, _ := strings.clone(s)
    return result
}

when FINDR_PARALLEL {
    WalkerPool :: struct {
        queue: [dynamic]string,
        queue_mutex: sync.Mutex,
        queue_sema: sync.Atomic_Sema,
        results: ^[dynamic]string,
        results_mutex: sync.Mutex,
        active: i64,
        done: sync.One_Shot_Event,
        threads: [dynamic]^thread.Thread,
    }

    walk_parallel :: proc(root: string, results: ^[dynamic]string) {
        pool := new(WalkerPool)
        pool.queue = make([dynamic]string)
        pool.results = results
        pool.active = 1
        pool.threads = make([dynamic]^thread.Thread)

        root_clone, _ := strings.clone(root)
        append(&pool.queue, root_clone)
        sync.atomic_sema_post(&pool.queue_sema)

        num_threads := FINDR_THREADS
        for i in 0..<num_threads {
            t := thread.create(walk_worker)
            t.data = rawptr(pool)
            t.init_context = context
            thread.start(t)
            append(&pool.threads, t)
        }

        sync.one_shot_event_wait(&pool.done)

        for _ in 0..<num_threads {
            sync.atomic_sema_post(&pool.queue_sema)
        }

        for t in pool.threads {
            thread.destroy(t)
        }
        delete(pool.threads)
        for path in pool.queue {
            delete(path)
        }
        delete(pool.queue)
        free(pool)
    }

    push_work :: proc(pool: ^WalkerPool, path: string) {
        sync.atomic_add_explicit(&pool.active, 1, .Relaxed)
        sync.mutex_lock(&pool.queue_mutex)
        append(&pool.queue, path)
        sync.mutex_unlock(&pool.queue_mutex)
        sync.atomic_sema_post(&pool.queue_sema)
    }

    process_dir_parallel :: proc(pool: ^WalkerPool, dir_path: string) {
        has_git := false
        entries := read_dir_entries(dir_path, &has_git)
        defer free_entries(&entries)

        if has_git {
            gi := load_gitignore(dir_path)
            defer if gi != nil {
                destroy(gi)
                free(gi)
            }

            for entry in entries {
                if entry.name == ".git" do continue
                is_dir := entry.type == .DIR
                if gi != nil && is_ignored(gi, entry.name, is_dir) {
                    if !is_dir {
                        full_path := join_path(dir_path, entry.name)
                        sync.mutex_lock(&pool.results_mutex)
                        append(pool.results, full_path)
                        sync.mutex_unlock(&pool.results_mutex)
                    }
                    continue
                }
                if is_dir {
                    child_path := join_path(dir_path, entry.name)
                    push_work(pool, child_path)
                }
            }
        } else {
            for entry in entries {
                if entry.type == .DIR {
                    child_path := join_path(dir_path, entry.name)
                    push_work(pool, child_path)
                }
            }
        }
    }

    walk_worker :: proc(t: ^thread.Thread) {
        pool := cast(^WalkerPool) t.data

        for {
            sync.atomic_sema_wait(&pool.queue_sema)

            sync.mutex_lock(&pool.queue_mutex)
            if len(pool.queue) == 0 {
                sync.mutex_unlock(&pool.queue_mutex)
                if sync.atomic_load_explicit(&pool.active, .Acquire) == 0 {
                    sync.one_shot_event_signal(&pool.done)
                }
                break
            }
            last := len(pool.queue) - 1
            dir_path := pool.queue[last]
            ordered_remove(&pool.queue, last)
            sync.mutex_unlock(&pool.queue_mutex)

            process_dir_parallel(pool, dir_path)
            delete(dir_path)

            old := sync.atomic_sub_explicit(&pool.active, 1, .Release)
            if old == 1 {
                sync.one_shot_event_signal(&pool.done)
            }
        }
    }
}