/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.nio.fs;

import java.nio.*;

import java.nio.file.*;

import java.nio.file.attribute.*;

import java.nio.charset.*;

import java.nio.channels.*;

import java.security.AccessController;

import java.io.*;

import java.net.URI;

import java.util.*;

import java.lang.ref.SoftReference;

import sun.security.util.SecurityConstants;

import static sun.nio.fs.UnixNativeDispatcher.*;

import static sun.nio.fs.UnixConstants.*;

/**

 * Solaris/Linux implementation of java.nio.file.Path

 */

class UnixPath

    extends AbstractPath

{

    private static ThreadLocal<SoftReference<CharsetEncoder>> encoder =

        new ThreadLocal<SoftReference<CharsetEncoder>>();

    // FIXME - eliminate this reference to reduce space

    private final UnixFileSystem fs;

    // internal representation

    private final byte[] path;

    // String representation (created lazily)

    private volatile String stringValue;

    // cached hashcode (created lazily, no need to be volatile)

    private int hash;

    // array of offsets of elements in path (created lazily)

    private volatile int[] offsets;

    UnixPath(UnixFileSystem fs, byte[] path) {

        this.fs = fs;

        this.path = path;

    }

    UnixPath(UnixFileSystem fs, String input) {

        // removes redundant slashes and checks for invalid characters

        this(fs, encode(normalizeAndCheck(input)));

    }

    // package-private

    // removes redundant slashes and check input for invalid characters

    static String normalizeAndCheck(String input) {

        int n = input.length();

        if (n == 0)

            throw new InvalidPathException(input, "Path is empty");

        char prevChar = 0;

        for (int i=0; i < n; i++) {

            char c = input.charAt(i);

            if ((c == '/') && (prevChar == '/'))

                return normalize(input, n, i - 1);

            checkNotNul(input, c);

            prevChar = c;

        }

        if (prevChar == '/')

            return normalize(input, n, n - 1);

        return input;

    }

    private static void checkNotNul(String input, char c) {

        if (c == '\u0000')

            throw new InvalidPathException(input, "Nul character not allowed");

    }

    private static String normalize(String input, int len, int off) {

        if (len == 0)

            return input;

        int n = len;

        while ((n > 0) && (input.charAt(n - 1) == '/')) n--;

        if (n == 0)

            return "/";

        StringBuilder sb = new StringBuilder(input.length());

        if (off > 0)

            sb.append(input.substring(0, off));

        char prevChar = 0;

        for (int i=off; i < n; i++) {

            char c = input.charAt(i);

            if ((c == '/') && (prevChar == '/'))

                continue;

            checkNotNul(input, c);

            sb.append(c);

            prevChar = c;

        }

        return sb.toString();

    }

    // encodes the given path-string into a sequence of bytes

    private static byte[] encode(String input) {

        SoftReference<CharsetEncoder> ref = encoder.get();

        CharsetEncoder ce = (ref != null) ? ref.get() : null;

        if (ce == null) {

            ce = Charset.defaultCharset().newEncoder()

                .onMalformedInput(CodingErrorAction.REPORT)

                .onUnmappableCharacter(CodingErrorAction.REPORT);

            encoder.set(new SoftReference<CharsetEncoder>(ce));

        }

        char[] ca = input.toCharArray();

        // size output buffer for worse-case size

        byte[] ba = new byte[(int)(ca.length * (double)ce.maxBytesPerChar())];

        // encode

        ByteBuffer bb = ByteBuffer.wrap(ba);

        CharBuffer cb = CharBuffer.wrap(ca);

        ce.reset();

        CoderResult cr = ce.encode(cb, bb, true);

        boolean error;

        if (!cr.isUnderflow()) {

            error = true;

        } else {

            cr = ce.flush(bb);

            error = !cr.isUnderflow();

        }

        if (error) {

            throw new InvalidPathException(input,

                "Malformed input or input contains unmappable chacraters");

        }

        // trim result to actual length if required

        int len = bb.position();

        if (len != ba.length)

            ba = Arrays.copyOf(ba, len);

        return ba;

    }

    // package-private

    byte[] asByteArray() {

        return path;

    }

    // use this path when making system/library calls

    byte[] getByteArrayForSysCalls() {

        // resolve against default directory if required (chdir allowed or

        // file system default directory is not working directory)

        if (getFileSystem().needToResolveAgainstDefaultDirectory()) {

            return resolve(getFileSystem().defaultDirectory(), path);

        } else {

            return path;

        }

    }

    // use this message when throwing exceptions

    String getPathForExecptionMessage() {

        return toString();

    }

    // use this path for permission checks

    String getPathForPermissionCheck() {

        if (getFileSystem().needToResolveAgainstDefaultDirectory()) {

            return new String(getByteArrayForSysCalls());

        } else {

            return toString();

        }

    }

    // Checks that the given file is a UnixPath

    private UnixPath checkPath(FileRef obj) {

        if (obj == null)

            throw new NullPointerException();

        if (!(obj instanceof UnixPath))

            throw new ProviderMismatchException();

        return (UnixPath)obj;

    }

    // create offset list if not already created

    private void initOffsets() {

        if (offsets == null) {

            int count, index;

            // count names

            count = 0;

            index = 0;

            while (index < path.length) {

                byte c = path[index++];

                if (c != '/') {

                    count++;

                    while (index < path.length && path[index] != '/')

                        index++;

                }

            }

            // populate offsets

            int[] result = new int[count];

            count = 0;

            index = 0;

            while (index < path.length) {

                byte c = path[index];

                if (c == '/') {

                    index++;

                } else {

                    result[count++] = index++;

                    while (index < path.length && path[index] != '/')

                        index++;

                }

            }

            synchronized (this) {

                if (offsets == null)

                    offsets = result;

            }

        }

    }

    @Override

    public UnixFileSystem getFileSystem() {

        return fs;

    }

    @Override

    public UnixPath getRoot() {

        if (path[0] == '/') {

            return getFileSystem().rootDirectory();

        } else {

            return null;

        }

    }

    @Override

    public UnixPath getName() {

        initOffsets();

        int count = offsets.length;

        if (count == 0)

            return null;  // no elements so no name

        if (count == 1 && path[0] != '/')

            return this;

        int lastOffset = offsets[count-1];

        int len = path.length - lastOffset;

        byte[] result = new byte[len];

        System.arraycopy(path, lastOffset, result, 0, len);

        return new UnixPath(getFileSystem(), result);

    }

    @Override

    public UnixPath getParent() {

        initOffsets();

        int count = offsets.length;

        if (count == 0) {

            // no elements so no parent

            return null;

        }

        int len = offsets[count-1] - 1;

        if (len <= 0) {

            // parent is root only (may be null)

            return getRoot();

        }

        byte[] result = new byte[len];

        System.arraycopy(path, 0, result, 0, len);

        return new UnixPath(getFileSystem(), result);

    }

    @Override

    public int getNameCount() {

        initOffsets();

        return offsets.length;

    }

    @Override

    public UnixPath getName(int index) {

        initOffsets();

        if (index < 0)

            throw new IllegalArgumentException();

        if (index >= offsets.length)

            throw new IllegalArgumentException();

        int begin = offsets[index];

        int len;

        if (index == (offsets.length-1)) {

            len = path.length - begin;

        } else {

            len = offsets[index+1] - begin - 1;

        }

        // construct result

        byte[] result = new byte[len];

        System.arraycopy(path, begin, result, 0, len);

        return new UnixPath(getFileSystem(), result);

    }

    @Override

    public UnixPath subpath(int beginIndex, int endIndex) {

        initOffsets();

        if (beginIndex < 0)

            throw new IllegalArgumentException();

        if (beginIndex >= offsets.length)

            throw new IllegalArgumentException();

        if (endIndex > offsets.length)

            throw new IllegalArgumentException();

        if (beginIndex >= endIndex) {

            throw new IllegalArgumentException();

        }

        // starting offset and length

        int begin = offsets[beginIndex];

        int len;

        if (endIndex == offsets.length) {

            len = path.length - begin;

        } else {

            len = offsets[endIndex] - begin - 1;

        }

        // construct result

        byte[] result = new byte[len];

        System.arraycopy(path, begin, result, 0, len);

        return new UnixPath(getFileSystem(), result);

    }

    @Override

    public boolean isAbsolute() {

        return (path[0] == '/');

    }

    // Resolve child against given base

    private static byte[] resolve(byte[] base, byte[] child) {

        if (child[0] == '/')

            return child;

        byte[] result;

        if (base.length == 1 && base[0] == '/') {

            result = new byte[child.length + 1];

            result[0] = '/';

            System.arraycopy(child, 0, result, 1, child.length);

        } else {

            result = new byte[base.length + 1 + child.length];

            System.arraycopy(base, 0, result, 0, base.length);

            result[base.length] = '/';

            System.arraycopy(child, 0, result,  base.length+1, child.length);

        }

        return result;

    }

    @Override

    public UnixPath resolve(Path obj) {

        if (obj == null)

            return this;

        byte[] other = checkPath(obj).path;

        if (other[0] == '/')

            return ((UnixPath)obj);

        byte[] result = resolve(path, other);

        return new UnixPath(getFileSystem(), result);

    }

    @Override

    public UnixPath resolve(String other) {

        return resolve(new UnixPath(getFileSystem(), other));

    }

    UnixPath resolve(byte[] other) {

        return resolve(new UnixPath(getFileSystem(), other));

    }

    @Override

    public UnixPath relativize(Path obj) {

        UnixPath other = checkPath(obj);

        if (other.equals(this))

            return null;

        // can only relativize paths of the same type

        if (this.isAbsolute() != other.isAbsolute())

            throw new IllegalArgumentException("'other' is different type of Path");

        int bn = this.getNameCount();

        int cn = other.getNameCount();

        // skip matching names

        int n = (bn > cn) ? cn : bn;

        int i = 0;

        while (i < n) {

            if (!this.getName(i).equals(other.getName(i)))

                break;

            i++;

        }

        int dotdots = bn - i;

        if (i < cn) {

            // remaining name components in other

            UnixPath remainder = other.subpath(i, cn);

            if (dotdots == 0)

                return remainder;

            // result is a  "../" for each remaining name in base

            // followed by the remaining names in other

            byte[] result = new byte[dotdots*3 + remainder.path.length];

            int pos = 0;

            while (dotdots > 0) {

                result[pos++] = (byte)'.';

                result[pos++] = (byte)'.';

                result[pos++] = (byte)'/';

                dotdots--;

            }

            System.arraycopy(remainder.path, 0, result, pos, remainder.path.length);

            return new UnixPath(getFileSystem(), result);

        } else {

            // no remaining names in other so result is simply a sequence of ".."

            byte[] result = new byte[dotdots*3 - 1];

            int pos = 0;

            while (dotdots > 0) {

                result[pos++] = (byte)'.';

                result[pos++] = (byte)'.';

                // no tailing slash at the end

                if (dotdots > 1)

                    result[pos++] = (byte)'/';

                dotdots--;

            }

            return new UnixPath(getFileSystem(), result);

        }

    }

    @Override

    public Path normalize() {

        final int count = getNameCount();

        if (count == 0)

            return this;

        boolean[] ignore = new boolean[count];      // true => ignore name

        int[] size = new int[count];                // length of name

        int remaining = count;                      // number of names remaining

        boolean hasDotDot = false;                  // has at least one ..

        boolean isAbsolute = path[0] == '/';

        // first pass:

        //   1. compute length of names

        //   2. mark all occurences of "." to ignore

        //   3. and look for any occurences of ".."

        for (int i=0; i<count; i++) {

            int begin = offsets[i];

            int len;

            if (i == (offsets.length-1)) {

                len = path.length - begin;

            } else {

                len = offsets[i+1] - begin - 1;

            }

            size[i] = len;

            if (path[begin] == '.') {

                if (len == 1) {

                    ignore[i] = true;  // ignore  "."

                    remaining--;

                }

                else {

                    if (path[begin+1] == '.')   // ".." found

                        hasDotDot = true;

                }

            }

        }

        // multiple passes to eliminate all occurences of name/..

        if (hasDotDot) {

            int prevRemaining;

            do {

                prevRemaining = remaining;

                int prevName = -1;

                for (int i=0; i<count; i++) {

                    if (ignore[i])

                        continue;

                    // not a ".."

                    if (size[i] != 2) {

                        prevName = i;

                        continue;

                    }

                    int begin = offsets[i];

                    if (path[begin] != '.' || path[begin+1] != '.') {

                        prevName = i;

                        continue;

                    }

                    // ".." found

                    if (prevName >= 0) {

                        // name/<ignored>/.. found so mark name and ".." to be

                        // ignored

                        ignore[prevName] = true;

                        ignore[i] = true;

                        remaining = remaining - 2;

                        prevName = -1;

                    } else {

                        // Case: /<ignored>/.. so mark ".." as ignored

                        if (isAbsolute) {

                            boolean hasPrevious = false;

                            for (int j=0; j<i; j++) {

                                if (!ignore[j]) {

                                    hasPrevious = true;

                                    break;

                                }

                            }