import { join, parse } from "node:path"
import { fileURLToPath } from "node:url"

export type PathString = string
export interface PathObject {
  path: string
  root: string
  dir: string
  base: string
  ext: string
  name: string
  separator: string
}
export type PathUnion = PathString | PathObject

export const pathStringToObject = (pathString: string): PathObject => {
  const pathObject = parse(pathString)

  return {
    root: pathObject.root,
    path: pathString,
    dir: pathObject.dir,
    base: pathObject.base,
    ext: pathObject.ext,
    name: pathObject.name,
    separator: join("a", "b").replaceAll("a", "").replaceAll("b", ""),
  }
}

export const pathObjectToString = (pathObject: PathObject): string => {
  return pathObject.path
}

export const toPathObject = (path: PathUnion): PathObject => {
  if (typeof path === "string") {
    if (isFileUrl(path)) {
      return fileUrlToPathObject(path)
    } else {
      return pathStringToObject(path)
    }
  } else {
    return path
  }
}

export const toPathString = (path: PathUnion): string => {
  if (typeof path === "string") {
    if (isFileUrl(path)) {
      return fileUrlToPathString(path)
    } else {
      return path
    }
  } else {
    return pathObjectToString(path)
  }
}

export const isFileUrl = (url: string): boolean => {
  try {
    const parsedUrl = new URL(url)
    return parsedUrl.protocol === "file:"
  } catch {
    return false
  }
}

export const fileUrlToPathString = (fileUrl: string): PathString => {
  return fileURLToPath(fileUrl)
}

export const fileUrlToPathObject = (fileUrl: string): PathObject => {
  const pathString = fileUrlToPathString(fileUrl)
  const pathObject = pathStringToObject(pathString)

  return pathObject
}