/*
 * Trident - A Multithreaded Server Alternative
 * Copyright 2014 The TridentSDK Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.tridentsdk.server.netty;

import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;

import javax.annotation.concurrent.ThreadSafe;
import java.math.BigInteger;
import java.nio.charset.Charset;

/**
 * Utility class to help decode the bytes from a backed buffer serializer
 *
 * @author The TridentSDK Team
 */
@ThreadSafe
public final class Codec {
    //Current charset used by strings is UTF_8
    /**
     * The charset used for Strings
     */
    public static final Charset CHARSET = Charsets.UTF_8;

    private Codec() {
    } // Suppress initialization of utility class

    /**
     * Read a string from the encoded buffer
     *
     * @param buf the buffer to decode the string from
     * @return the decoded string read from the buffer
     */
    public static String readString(ByteBuf buf) {
        //Reads the length of the string
        int length = readVarInt32(buf);
        byte[] bytes = new byte[length];
        buf.readBytes(bytes);

        return new String(bytes, CHARSET);
    }

    /**
     * Gets the byte length of provided integer
     *
     * @param integer integer to get the byte length of
     * @return byte length of the integer
     */
    public static int sizeOf(int integer) {
        return BigInteger.valueOf(integer).toByteArray().length;
    }

    /**
     * Writes a string to the buffer
     *
     * @param buf the buffer to decode the string from
     */
    public static void writeString(ByteBuf buf, String string) {
        if (string == null) {
            return;
        }
        //Writes the length of the string
        writeVarInt32(buf, string.length());

        //Writes the bytes of the string
        byte[] bytes = string.getBytes(CHARSET);
        buf.writeBytes(bytes);
    }

    /**
     * Reads a 32bit VarInt from the encoded buffer
     *
     * @param buf the buffer to decode the integer from
     * @return the decoded integer read from the buffer
     */
    public static int readVarInt32(ByteBuf buf) {
        //The result we will return
        int result = 0;

        //How much to indent the current bytes
        int indent = 0;
        int b = (int) buf.readByte();

        //If below, it means there are more bytes
        // 0x80 = 128 for those that don't know
        while ((b & 0x80) == 0x80) {
            Preconditions.checkArgument(indent < 21, "Too many bytes for a VarInt32.");

            //Adds the byte in the appropriate position (first byte goes last, etc.)
            result += (b & 0x7f) << indent;
            indent += 7;

            //Reads the next byte
            b = (int) buf.readByte();
        }

        // 0x7f = 127
        result += (b & 0x7f) << indent;
        return result;
    }

    /**
     * Writes an int value as a VarInt to the buffer.
     *
     * @param buf      the buffer to encode into
     * @param toEncode the integer encode into buf
     */
    public static void writeVarInt32(ByteBuf buf, int toEncode) {
        //Loops through until the currently 'selected' set of 7 bits is the terminating one
        while ((toEncode & 0xFFFFFF80) != 0L) {
            /*Writes the selected 7 bits, and adds a 1 at the front
            signifying that there is another byte*/
            buf.writeByte(toEncode & 0x7F | 0x80);
            //Selects the next set of 7 bits
            toEncode >>>= 7;
        }
        //Writes the final terminating byte with a 0 at the front to signify termination
        buf.writeByte(toEncode & 0x7F);
    }

    /**
     * Reads a 64bit VarInt from the encoded buffer
     *
     * @param buf the buffer to decode the long from
     * @return the decoded long read from the buffer
     */
    public static long readVarInt64(ByteBuf buf) {
        //The result we will return
        long result = 0L;

        //How much to indent the current bytes
        int indent = 0;
        long b = (long) buf.readByte();

        //If below, it means there are more bytes
        while ((b & 0x80L) == 0x80) {
            Preconditions.checkArgument(indent < 49, "Too many bytes for a VarInt64.");

            //Adds the byte in the appropriate position (first byte goes last, etc.)
            result += (b & 0x7fL) << indent;
            indent += 7;

            //Reads the next byte
            b = (long) buf.readByte();
        }

        return result += (b & 0x7fL) << indent;
    }

    /**
     * Writes a long value as a VarInt to the buffer.
     *
     * @param buf      the buffer to encode into
     * @param toEncode the integer encode into buf
     */
    public static void writeVarInt64(ByteBuf buf, long toEncode) {
        //Loops through until the currently 'selected' set of 7 bits is the terminating one
        while ((toEncode & 0xFFFFFFFFFFFFFF80L) != 0L) {
            /*Writes the selected 7 bits, and adds a 1 at the front
            signifying that there is another byte*/
            buf.writeByte((int) (toEncode & 0x7FL | 0x80L));
            //Selects the next set of 7 bits
            toEncode >>>= 7L;
        }
        //Writes the final terminating byte with a 0 at the front to signify termination
        buf.writeByte((int) (toEncode & 0x7FL));
    }

    /**
     * Writes the full contents of a ByteBuf to an array
     *
     * @param buf the buffer to get data from
     * @return bytes the array of bytes
     */
    public static byte[] asArray(ByteBuf buf) {
        return asArray(buf, buf.readableBytes());
    }

    /**
     * Writes a certain length of bytes from a ByteBuf to an array
     *
     * @param buf    the buffer to get data from
     * @param length the length to toPacket
     * @return bytes the array of bytes
     */
    public static byte[] asArray(ByteBuf buf, int length) {
        byte[] bytes = new byte[length];
        buf.getBytes(buf.readerIndex(), bytes);
        return bytes;
    }
}