/*
 * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
 * 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 java.net.http.internal.frame;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

/**
 * Frames Encoder
 *
 * Encode framed into ByteBuffers.
 * The class is stateless.
 */
public class FramesEncoder {


    public FramesEncoder() {
    }

    public List<ByteBuffer> encodeFrames(List<HeaderFrame> frames) {
        List<ByteBuffer> bufs = new ArrayList<>(frames.size() * 2);
        for (HeaderFrame f : frames) {
            bufs.addAll(encodeFrame(f));
        }
        return bufs;
    }

    public ByteBuffer encodeConnectionPreface(byte[] preface, SettingsFrame frame) {
        final int length = frame.length();
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + length + preface.length);
        buf.put(preface);
        putSettingsFrame(buf, frame, length);
        buf.flip();
        return buf;
    }

    public List<ByteBuffer> encodeFrame(Http2Frame frame) {
        switch (frame.type()) {
            case DataFrame.TYPE:
                return encodeDataFrame((DataFrame) frame);
            case HeadersFrame.TYPE:
                return encodeHeadersFrame((HeadersFrame) frame);
            case PriorityFrame.TYPE:
                return encodePriorityFrame((PriorityFrame) frame);
            case ResetFrame.TYPE:
                return encodeResetFrame((ResetFrame) frame);
            case SettingsFrame.TYPE:
                return encodeSettingsFrame((SettingsFrame) frame);
            case PushPromiseFrame.TYPE:
                return encodePushPromiseFrame((PushPromiseFrame) frame);
            case PingFrame.TYPE:
                return encodePingFrame((PingFrame) frame);
            case GoAwayFrame.TYPE:
                return encodeGoAwayFrame((GoAwayFrame) frame);
            case WindowUpdateFrame.TYPE:
                return encodeWindowUpdateFrame((WindowUpdateFrame) frame);
            case ContinuationFrame.TYPE:
                return encodeContinuationFrame((ContinuationFrame) frame);
            default:
                throw new UnsupportedOperationException("Not supported frame "+frame.type()+" ("+frame.getClass().getName()+")");
        }
    }

    private static final int NO_FLAGS = 0;
    private static final int ZERO_STREAM = 0;

    private List<ByteBuffer> encodeDataFrame(DataFrame frame) {
        // non-zero stream
        assert frame.streamid() != 0;
        ByteBuffer buf = encodeDataFrameStart(frame);
        if (frame.getFlag(DataFrame.PADDED)) {
            return joinWithPadding(buf, frame.getData(), frame.getPadLength());
        } else {
            return join(buf, frame.getData());
        }
    }

    private ByteBuffer encodeDataFrameStart(DataFrame frame) {
        boolean isPadded = frame.getFlag(DataFrame.PADDED);
        final int length = frame.getDataLength() + (isPadded ? (frame.getPadLength() + 1) : 0);
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + (isPadded ? 1 : 0));
        putHeader(buf, length, DataFrame.TYPE, frame.getFlags(), frame.streamid());
        if (isPadded) {
            buf.put((byte) frame.getPadLength());
        }
        buf.flip();
        return buf;
    }

    private List<ByteBuffer> encodeHeadersFrame(HeadersFrame frame) {
        // non-zero stream
        assert frame.streamid() != 0;
        ByteBuffer buf = encodeHeadersFrameStart(frame);
        if (frame.getFlag(HeadersFrame.PADDED)) {
            return joinWithPadding(buf, frame.getHeaderBlock(), frame.getPadLength());
        } else {
            return join(buf, frame.getHeaderBlock());
        }
    }

    private ByteBuffer encodeHeadersFrameStart(HeadersFrame frame) {
        boolean isPadded = frame.getFlag(HeadersFrame.PADDED);
        boolean hasPriority = frame.getFlag(HeadersFrame.PRIORITY);
        final int length = frame.getHeaderLength() + (isPadded ? (frame.getPadLength() + 1) : 0) + (hasPriority ? 5 : 0);
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + (isPadded ? 1 : 0) + (hasPriority ? 5 : 0));
        putHeader(buf, length, HeadersFrame.TYPE, frame.getFlags(), frame.streamid());
        if (isPadded) {
            buf.put((byte) frame.getPadLength());
        }
        if (hasPriority) {
            putPriority(buf, frame.getExclusive(), frame.getStreamDependency(), frame.getWeight());
        }
        buf.flip();
        return buf;
    }

    private List<ByteBuffer> encodePriorityFrame(PriorityFrame frame) {
        // non-zero stream; no flags
        assert frame.streamid() != 0;
        final int length = 5;
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + length);
        putHeader(buf, length, PriorityFrame.TYPE, NO_FLAGS, frame.streamid());
        putPriority(buf, frame.exclusive(), frame.streamDependency(), frame.weight());
        buf.flip();
        return List.of(buf);
    }

    private List<ByteBuffer> encodeResetFrame(ResetFrame frame) {
        // non-zero stream; no flags
        assert frame.streamid() != 0;
        final int length = 4;
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + length);
        putHeader(buf, length, ResetFrame.TYPE, NO_FLAGS, frame.streamid());
        buf.putInt(frame.getErrorCode());
        buf.flip();
        return List.of(buf);
    }

    private List<ByteBuffer> encodeSettingsFrame(SettingsFrame frame) {
        // only zero stream
        assert frame.streamid() == 0;
        final int length = frame.length();
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + length);
        putSettingsFrame(buf, frame, length);
        buf.flip();
        return List.of(buf);
    }

    private List<ByteBuffer> encodePushPromiseFrame(PushPromiseFrame frame) {
        // non-zero stream
        assert frame.streamid() != 0;
        boolean isPadded = frame.getFlag(PushPromiseFrame.PADDED);
        final int length = frame.getHeaderLength() + (isPadded ? 5 : 4);
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + (isPadded ? 5 : 4));
        putHeader(buf, length, PushPromiseFrame.TYPE, frame.getFlags(), frame.streamid());
        if (isPadded) {
            buf.put((byte) frame.getPadLength());
        }
        buf.putInt(frame.getPromisedStream());
        buf.flip();

        if (frame.getFlag(PushPromiseFrame.PADDED)) {
            return joinWithPadding(buf, frame.getHeaderBlock(), frame.getPadLength());
        } else {
            return join(buf, frame.getHeaderBlock());
        }
    }

    private List<ByteBuffer> encodePingFrame(PingFrame frame) {
        // only zero stream
        assert frame.streamid() == 0;
        final int length = 8;
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + length);
        putHeader(buf, length, PingFrame.TYPE, frame.getFlags(), ZERO_STREAM);
        buf.put(frame.getData());
        buf.flip();
        return List.of(buf);
    }

    private List<ByteBuffer> encodeGoAwayFrame(GoAwayFrame frame) {
        // only zero stream; no flags
        assert frame.streamid() == 0;
        byte[] debugData = frame.getDebugData();
        final int length = 8 + debugData.length;
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + length);
        putHeader(buf, length, GoAwayFrame.TYPE, NO_FLAGS, ZERO_STREAM);
        buf.putInt(frame.getLastStream());
        buf.putInt(frame.getErrorCode());
        if (debugData.length > 0) {
            buf.put(debugData);
        }
        buf.flip();
        return List.of(buf);
    }

    private List<ByteBuffer> encodeWindowUpdateFrame(WindowUpdateFrame frame) {
        // any stream; no flags
        final int length = 4;
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE + length);
        putHeader(buf, length, WindowUpdateFrame.TYPE, NO_FLAGS, frame.streamid);
        buf.putInt(frame.getUpdate());
        buf.flip();
        return List.of(buf);
    }

    private List<ByteBuffer> encodeContinuationFrame(ContinuationFrame frame) {
        // non-zero stream;
        assert frame.streamid() != 0;
        final int length = frame.getHeaderLength();
        ByteBuffer buf = getBuffer(Http2Frame.FRAME_HEADER_SIZE);
        putHeader(buf, length, ContinuationFrame.TYPE, frame.getFlags(), frame.streamid());
        buf.flip();
        return join(buf, frame.getHeaderBlock());
    }

    private List<ByteBuffer> joinWithPadding(ByteBuffer buf, List<ByteBuffer> data, int padLength) {
        int len = data.size();
        if (len == 0) return List.of(buf, getPadding(padLength));
        else if (len == 1) return List.of(buf, data.get(0), getPadding(padLength));
        else if (len == 2) return List.of(buf, data.get(0), data.get(1), getPadding(padLength));
        List<ByteBuffer> res = new ArrayList<>(len+2);
        res.add(buf);
        res.addAll(data);
        res.add(getPadding(padLength));
        return res;
    }

    private List<ByteBuffer> join(ByteBuffer buf, List<ByteBuffer> data) {
        int len = data.size();
        if (len == 0) return List.of(buf);
        else if (len == 1) return List.of(buf, data.get(0));
        else if (len == 2) return List.of(buf, data.get(0), data.get(1));
        List<ByteBuffer> joined = new ArrayList<>(len + 1);
        joined.add(buf);
        joined.addAll(data);
        return joined;
    }

    private void putSettingsFrame(ByteBuffer buf, SettingsFrame frame, int length) {
        // only zero stream;
        assert frame.streamid() == 0;
        putHeader(buf, length, SettingsFrame.TYPE, frame.getFlags(), ZERO_STREAM);
        frame.toByteBuffer(buf);
    }

    private void putHeader(ByteBuffer buf, int length, int type, int flags, int streamId) {
        int x = (length << 8) + type;
        buf.putInt(x);
        buf.put((byte) flags);
        buf.putInt(streamId);
    }

    private void putPriority(ByteBuffer buf, boolean exclusive, int streamDependency, int weight) {
        buf.putInt(exclusive ? (1 << 31) + streamDependency : streamDependency);
        buf.put((byte) weight);
    }

    private ByteBuffer getBuffer(int capacity) {
        return ByteBuffer.allocate(capacity);
    }

    public ByteBuffer getPadding(int length) {
        if (length > 255) {
            throw new IllegalArgumentException("Padding too big");
        }
        return ByteBuffer.allocate(length); // zeroed!
    }

}