// SPDX-License-Identifier: MPL-2.0

// SPDX-FileCopyrightText: 2026 hyperpolymath

module PathHandler;

use prelude::{Option, Some, None, Result, Ok, Err};

use string::{contains, ends_with, starts_with};

use SafePath::{is_safe, safe_join, sanitize_filename};

pub type PathError = TraversalDetected | InvalidPath | PermissionDenied | NotFound;

pub type ValidatedPath = | VP(String);

pub fn unwrap_path(p: ValidatedPath) -> String {

match p {

VP(s) => s

}

}

pub fn validate(path: String) -> Option<ValidatedPath> {

if is_safe(path) {

Some(VP(path))

} else {

None

}

}

pub fn path_join(base: ValidatedPath, components: [String]) -> Result<ValidatedPath, PathError> {

let base_str = unwrap_path(base);

match safe_join(base_str, components) {

Some(joined) => Ok(VP(joined)),

None => Err(TraversalDetected)

}

}

pub fn sanitize(filename: String) -> String {

sanitize_filename(filename)

}

pub fn is_within(path: ValidatedPath, base: ValidatedPath) -> Bool {

let path_str = unwrap_path(path);

let base_str = unwrap_path(base);

starts_with(path_str, base_str)

}

pub fn get_parent(path: ValidatedPath) -> Option<ValidatedPath> {

let s = unwrap_path(path);

let n = len(s);

let mut last_slash = 0 - 1;

let mut i = 0;

while i < n {

if char_to_int(string_get(s, i)) == 47 {

last_slash = i;

}

i = i + 1;

}

if last_slash <= 0 {

None

} else {

Some(VP(string_sub(s, 0, last_slash)))

}

}

pub fn filename(path: ValidatedPath) -> String {

let s = unwrap_path(path);

let n = len(s);

let mut last_slash = 0 - 1;

let mut i = 0;

while i < n {

if char_to_int(string_get(s, i)) == 47 {

last_slash = i;

}

i = i + 1;

}

if last_slash < 0 {

s

} else {

string_sub(s, last_slash + 1, n - last_slash - 1)

}

}

pub fn has_extension(path: ValidatedPath, ext: String) -> Bool {

let s = unwrap_path(path);

ends_with(s, ext)

}

pub fn from_trusted(path: String) -> ValidatedPath {

VP(path)

}

pub fn is_excluded(path: ValidatedPath, excludes: [String]) -> Bool {

let s = unwrap_path(path);

for excl in excludes {

if contains(s, excl) {

return true;

}

}

false

}