/*

 * 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.charset.*;

import java.io.*;

import java.net.URI;

import java.util.*;

import java.lang.ref.SoftReference;

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();

        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 {

            if (!isEmpty()) {

                return path;

            } else {

                // empty path case will access current directory

                byte[] here = { '.' };

                return here;

            }

        }

    }

    // 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

    static UnixPath toUnixPath(Path 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;

            if (isEmpty()) {

                // empty path has one name

                count = 1;

            } else {

                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;

            }

        }

    }

    // returns {@code true} if this path is an empty path

    private boolean isEmpty() {

        return path.length == 0;

    }

    // returns an empty path

    private UnixPath emptyPath() {

        return new UnixPath(getFileSystem(), new byte[0]);

    }

    @Override

    public UnixFileSystem getFileSystem() {

        return fs;

    }

    @Override

    public UnixPath getRoot() {

        if (path.length > 0 && path[0] == '/') {

            return getFileSystem().rootDirectory();

        } else {

            return null;

        }

    }

    @Override

    public UnixPath getFileName() {

        initOffsets();

        int count = offsets.length;

        // no elements so no name

        if (count == 0)

            return null;

        // one name element and no root component

        if (count == 1 && path.length > 0 && 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.length > 0 && path[0] == '/');

    }

    // Resolve child against given base

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

        int baseLength = base.length;

        int childLength = child.length;

        if (childLength == 0)

            return base;

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

            return child;

        byte[] result;

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

            result = new byte[childLength + 1];

            result[0] = '/';

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

        } else {

            result = new byte[baseLength + 1 + childLength];

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

            result[base.length] = '/';

            System.arraycopy(child, 0, result, baseLength+1, childLength);

        }

        return result;

    }

    @Override

    public UnixPath resolve(Path obj) {

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

        if (other.length > 0 && other[0] == '/')

            return ((UnixPath)obj);

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

        return new UnixPath(getFileSystem(), result);

    }

    UnixPath resolve(byte[] other) {

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

    }

    @Override

    public UnixPath relativize(Path obj) {

        UnixPath other = toUnixPath(obj);

        if (other.equals(this))

            return emptyPath();

        // can only relativize paths of the same type

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

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

        // this path is the empty path

        if (this.isEmpty())

            return other;

        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;

            // other is the empty path

            boolean isOtherEmpty = other.isEmpty();

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

            // followed by the remaining names in other. If the remainder is

            // the empty path then we don't add the final trailing slash.

            int len = dotdots*3 + remainder.path.length;

            if (isOtherEmpty) {

                assert remainder.isEmpty();

                len--;

            }

            byte[] result = new byte[len];

            int pos = 0;

            while (dotdots > 0) {

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

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

                if (isOtherEmpty) {

                    if (dotdots > 1) result[pos++] = (byte)'/';

                } else {

                    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 = isAbsolute();

        // 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;

                }

            }

        }