// 
// Decompiled by Procyon v0.6.0
// 

package com.hypixel.hytale.common.util;

import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.util.function.Consumer;
import javax.annotation.Nullable;
import java.net.URL;
import java.nio.file.Paths;
import java.util.Objects;
import javax.annotation.Nonnull;
import java.nio.file.Path;
import java.util.regex.Pattern;

public class PathUtil
{
    private static final Pattern PATH_PATTERN;
    
    @Nonnull
    public static Path getParent(@Nonnull final Path path) {
        if (path.isAbsolute()) {
            return path.getParent().normalize();
        }
        final Path parentAbsolute = path.toAbsolutePath().getParent();
        final Path parent = path.resolve(relativize(path, parentAbsolute));
        return parent.normalize();
    }
    
    @Nonnull
    public static Path relativize(@Nonnull final Path pathA, @Nonnull final Path pathB) {
        final Path absolutePathA = pathA.toAbsolutePath();
        final Path absolutePathB = pathB.toAbsolutePath();
        if (Objects.equals(absolutePathA.getRoot(), absolutePathB.getRoot())) {
            return absolutePathA.normalize().relativize(absolutePathB.normalize()).normalize();
        }
        return absolutePathB.normalize();
    }
    
    @Nonnull
    public static Path relativizePretty(@Nonnull final Path pathA, @Nonnull final Path pathB) {
        final Path absolutePathA = pathA.toAbsolutePath().normalize();
        final Path absolutePathB = pathB.toAbsolutePath().normalize();
        final Path absoluteUserHome = getUserHome().toAbsolutePath();
        if (Objects.equals(absoluteUserHome.getRoot(), absolutePathB.getRoot())) {
            final Path relativizedHome = absoluteUserHome.relativize(absolutePathB).normalize();
            if (Objects.equals(absolutePathA.getRoot(), absolutePathB.getRoot())) {
                final Path relativized = absolutePathA.relativize(absolutePathB).normalize();
                if (relativizedHome.getNameCount() < relativized.getNameCount()) {
                    return Paths.get("~", new String[0]).resolve(relativizedHome);
                }
                return relativized;
            }
            else {
                if (relativizedHome.getNameCount() < absolutePathB.getNameCount()) {
                    return Paths.get("~", new String[0]).resolve(relativizedHome);
                }
                return absolutePathB;
            }
        }
        else {
            if (Objects.equals(absolutePathA.getRoot(), absolutePathB.getRoot())) {
                return absolutePathA.relativize(absolutePathB).normalize();
            }
            return absolutePathB;
        }
    }
    
    @Nonnull
    public static Path get(@Nonnull final String path) {
        return get(Paths.get(path, new String[0]));
    }
    
    @Nonnull
    public static Path get(@Nonnull final Path path) {
        return (path.toString().charAt(0) == '~') ? getUserHome().resolve(path.subpath(1, path.getNameCount())).normalize() : path.normalize();
    }
    
    @Nonnull
    public static Path getUserHome() {
        return Paths.get(System.getProperty("user.home"), new String[0]);
    }
    
    public static String getFileName(@Nonnull final URL extUrl) {
        final String[] pathContents = PathUtil.PATH_PATTERN.split(extUrl.getPath());
        final String fileName = pathContents[pathContents.length - 1];
        if (fileName.isEmpty() && pathContents.length > 1) {
            return pathContents[pathContents.length - 2];
        }
        return fileName;
    }
    
    public static boolean isChildOf(@Nonnull final Path parent, @Nonnull final Path child) {
        return child.toAbsolutePath().normalize().startsWith(parent.toAbsolutePath().normalize());
    }
    
    public static void forEachParent(@Nonnull final Path path, @Nullable final Path limit, @Nonnull final Consumer<Path> consumer) {
        Path parent = path.toAbsolutePath();
        if (Files.isRegularFile(parent, new LinkOption[0])) {
            parent = parent.getParent();
        }
        if (parent == null) {
            return;
        }
        do {
            consumer.accept(parent);
        } while ((parent = parent.getParent()) != null && (limit == null || isChildOf(limit, parent)));
    }
    
    @Nonnull
    public static String getFileExtension(@Nonnull final Path path) {
        final String fileName = path.getFileName().toString();
        final int index = fileName.lastIndexOf(46);
        if (index == -1) {
            return "";
        }
        return fileName.substring(index);
    }
    
    @Nonnull
    public static String toUnixPathString(@Nonnull final Path path) {
        if ("\\".equals(path.getFileSystem().getSeparator())) {
            return path.toString().replace("\\", "/");
        }
        return path.toString();
    }
    
    static {
        PATH_PATTERN = Pattern.compile("[\\\\/]");
    }
}