/*******************************************************************************
 * Copyright (c) 2015, 2018 Ericsson
 *
 * All rights reserved. This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *   Bernd Hufmann - Initial API and implementation
 *******************************************************************************/
package org.eclipse.tracecompass.ctf.core.trace;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;

import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.CTFStrings;
import org.eclipse.tracecompass.ctf.core.event.IEventDefinition;
import org.eclipse.tracecompass.ctf.core.event.io.BitBuffer;
import org.eclipse.tracecompass.ctf.core.event.types.Definition;
import org.eclipse.tracecompass.ctf.core.event.types.FloatDeclaration;
import org.eclipse.tracecompass.ctf.core.event.types.FloatDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.ICompositeDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.IDeclaration;
import org.eclipse.tracecompass.ctf.core.event.types.ISimpleDatatypeDeclaration;
import org.eclipse.tracecompass.ctf.core.event.types.SimpleDatatypeDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.StringDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.StructDefinition;
import org.eclipse.tracecompass.internal.ctf.core.Activator;
import org.eclipse.tracecompass.internal.ctf.core.SafeMappedByteBuffer;
import org.eclipse.tracecompass.internal.ctf.core.trace.CTFPacketReader;
import org.eclipse.tracecompass.internal.ctf.core.trace.StreamInputPacketIndexEntry;

/**
 * CTF trace packet writer.
 *
 * @author Bernd Hufmann
 * @since 1.0
 */
public class CTFStreamPacketOutputWriter {

    private CTFStreamInput fStreamInput;

    /**
     * Default constructor
     */
    public CTFStreamPacketOutputWriter() {
        throw new UnsupportedOperationException();
    }

    /**
     * Writer output
     *
     * @param streamInput
     *            the reference input stream to copy
     * @since 3.0
     */
    public CTFStreamPacketOutputWriter(@NonNull CTFStreamInput streamInput) {
        fStreamInput = streamInput;
    }

    /**
     * Writes a stream packet to the output file channel based on the packet
     * descriptor information.
     *
     * @param byteBuffer
     *            a byte buffer with packet to write
     * @param output
     *            a file channel
     * @throws IOException
     *             if a reading or writing error occurs
     */
    public void writePacket(ByteBuffer byteBuffer, FileChannel output) throws IOException {
        output.write(byteBuffer);
    }

    /**
     * Writes a stream packet to the output file channel based on the packet
     * descriptor information.
     *
     * @param entry
     *            the packet descriptor
     * @param output
     *            the file channel to write to
     * @param initialLost
     *            the offset initial lost events as the field is cumulative
     *
     * @throws IOException
     *             if a reading or writing error occurs
     * @throws CTFException
     *             ctf reading error
     * @since 3.0
     */
    public void writePacket(ICTFPacketDescriptor entry, FileChannel output, long initialLost) throws IOException, CTFException {
        long startOffsetBits = entry.getPayloadStartBits();
        long endOffsetBits = entry.getContentSizeBits();
        StructDefinition context = null;
        File file = fStreamInput.getFile();
        try (FileChannel fc = FileChannel.open(file.toPath(), StandardOpenOption.READ);) {
            ByteBuffer bb = SafeMappedByteBuffer.map(fc, FileChannel.MapMode.READ_ONLY, entry.getOffsetBytes(), (long) Math.ceil(entry.getContentSizeBits() / (double) Byte.SIZE));
            BitBuffer bbInput = new BitBuffer(bb);
            bbInput.position(entry.getPayloadStartBits());
            ICTFStream stream = fStreamInput.getStream();
            CTFTrace trace = stream.getTrace();
            CTFPacketReader currentPacketReader = new CTFPacketReader(
                    bbInput,
                    entry,
                    stream.getEventDeclarations(),
                    stream.getEventHeaderDeclaration(),
                    stream.getEventContextDecl(),
                    trace.getPacketHeaderDef(),
                    trace);
            if (entry instanceof StreamInputPacketIndexEntry) {
                context = ((StreamInputPacketIndexEntry) entry).getStreamPacketContextDef();
            }
            if (context == null) {
                return;
            }
            ICompositeDefinition tracePacketHeader = currentPacketReader.getTracePacketHeader();
            writeCustomPacket(entry, fc, output, startOffsetBits, endOffsetBits, context, tracePacketHeader, entry.getTimestampBegin(), initialLost);
        }
    }

    /**
     * Make a packet and write it to the fileChannel
     *
     * @param entry
     *            the reference packet descriptor
     * @param startTime
     *            startTime of the packet
     * @param endTime
     *            endTime of the packet
     * @param initialLost
     *            Initial quantity of lost events
     * @param output
     *            the file channel to write to
     * @throws IOException
     *             if a reading or writing error occurs
     * @throws CTFException
     *             ctf reading error
     * @since 3.0
     */
    public void writePacket(ICTFPacketDescriptor entry, long startTime, long endTime, long initialLost, FileChannel output) throws IOException, CTFException {
        if (entry.getTimestampBegin() > endTime || entry.getTimestampEnd() < startTime || startTime > endTime) {
            throw new IllegalStateException();
        }
        long startOffsetBits = entry.getPayloadStartBits();
        long endOffsetBits = entry.getContentSizeBits();
        StructDefinition context = null;
        File file = fStreamInput.getFile();
        try (FileChannel fc = FileChannel.open(file.toPath(), StandardOpenOption.READ);) {
            ByteBuffer bb = SafeMappedByteBuffer.map(fc, FileChannel.MapMode.READ_ONLY, entry.getOffsetBytes(), bitsToBytes(entry.getContentSizeBits()));
            BitBuffer bbInput = new BitBuffer(bb);
            bbInput.position(entry.getPayloadStartBits());
            ICTFStream stream = fStreamInput.getStream();
            CTFTrace trace = stream.getTrace();
            CTFPacketReader currentPacketReader = new CTFPacketReader(
                    bbInput,
                    entry,
                    stream.getEventDeclarations(),
                    stream.getEventHeaderDeclaration(),
                    stream.getEventContextDecl(),
                    trace.getPacketHeaderDef(),
                    trace);
            long lastLargeTimestamp = entry.getTimestampBegin();
            if (entry instanceof StreamInputPacketIndexEntry) {
                context = ((StreamInputPacketIndexEntry) entry).getStreamPacketContextDef();
            }
            if (context == null) {
                return;
            }
            boolean startIsSet = false;
            while (currentPacketReader.hasMoreEvents()) {

                IEventDefinition event = currentPacketReader.readNextEvent();
                long timestampInCycles = event.getTimestamp();
                if (!startIsSet) {
                    /*
                     * handle "P" and "I" framed timestamps. overwrite the
                     * timestamp if there is one before the trim
                     */
                    ICompositeDefinition eventHeader = event.getEventHeader();
                    Definition def = null;
                    if (eventHeader != null) {
                        def = eventHeader.getDefinition(CTFStrings.TIMESTAMP);
                    }
                    if (def == null && eventHeader instanceof StructDefinition) {
                        StructDefinition structDefinition = (StructDefinition) eventHeader;
                        def = structDefinition.lookupDefinition(CTFStrings.TIMESTAMP);
                    }
                    Definition definition = ((StreamInputPacketIndexEntry) entry).getStreamPacketContextDef().getDefinition(CTFStrings.TIMESTAMP_BEGIN);
                    if (definition != null && def != null && def.size() == definition.size()) {
                        lastLargeTimestamp = timestampInCycles;
                    }
                }
                if (timestampInCycles >= startTime && !startIsSet) {
                    startOffsetBits = currentPacketReader.getLocation();
                    startIsSet = true;
                }
                if (timestampInCycles > endTime + 1) {
                    endOffsetBits = currentPacketReader.getLocation();
                    break;
                }
            }
            if (startOffsetBits >= endOffsetBits) {
                return;
            }
            ICompositeDefinition tracePacketHeader = currentPacketReader.getTracePacketHeader();
            writeCustomPacket(entry, fc, output, startOffsetBits, endOffsetBits, context, tracePacketHeader, lastLargeTimestamp, initialLost);
        }
    }

    private static void writeCustomPacket(ICTFPacketDescriptor entry, FileChannel source, FileChannel output, long startOffsetBits, long endOffsetBits, StructDefinition packetContext, ICompositeDefinition tracePacketHeader, long startTime,
            long initialLost)
            throws IOException, CTFException {
        ByteBuffer inBuffer = SafeMappedByteBuffer.map(source, MapMode.READ_ONLY, entry.getOffsetBytes(), bitsToBytes(entry.getContentSizeBits()));
        int headerSizeBits = (int) (tracePacketHeader == null ? 0 : tracePacketHeader.size());
        int packetSizeBits = (int) (headerSizeBits + packetContext.size() + endOffsetBits - startOffsetBits);
        int alignmentSize = Byte.SIZE;
        int lastBitsOfBody = (int) (endOffsetBits % alignmentSize);
        int contentSizeBits = (lastBitsOfBody != 0) ? (packetSizeBits - alignmentSize + lastBitsOfBody) : packetSizeBits;
        byte[] toWrite = new byte[(int) bitsToBytes(packetSizeBits)];
        ByteBuffer buffer = ByteBuffer.wrap(toWrite);
        byte[] header = new byte[(int) bitsToBytes(headerSizeBits)];
        byte[] body = new byte[(int) bitsToBytes(endOffsetBits - startOffsetBits)];
        inBuffer.get(header);
        inBuffer.position((int) bitsToBytes(startOffsetBits));
        inBuffer.get(body);
        buffer.put(header);
        writeContext(startTime, packetContext, contentSizeBits, (int) bitsToBytes(packetSizeBits) * Byte.SIZE, initialLost, buffer);
        buffer.position((int) bitsToBytes(headerSizeBits + packetContext.size()));
        buffer.put(body);
        output.write(ByteBuffer.wrap(toWrite));
    }

    private static long bitsToBytes(long bits) {
        return (long) Math.ceil(bits / (double) Byte.SIZE);
    }

    private static void writeContext(long startTime, StructDefinition context, int newContentSize, int newPacketSize, long initialLost, @NonNull ByteBuffer buffer) throws CTFException {
        BitBuffer bb = new BitBuffer(buffer);
        bb.position(buffer.position() * Byte.SIZE);
        for (String field : context.getFieldNames()) {
            Definition def = context.getDefinition(field);
            IDeclaration declaration = def.getDeclaration();
            align(declaration.getAlignment(), bb);
            if (declaration instanceof ISimpleDatatypeDeclaration) {
                bb.setByteOrder(((ISimpleDatatypeDeclaration) declaration).getByteOrder());
            }
            if (def instanceof SimpleDatatypeDefinition) {
                SimpleDatatypeDefinition simpleDef = (SimpleDatatypeDefinition) def;
                int size = (int) simpleDef.size();
                if (field.equals(CTFStrings.PACKET_SIZE)) {
                    bb.putLong(size, newPacketSize);
                } else if (field.equals(CTFStrings.CONTENT_SIZE)) {
                    bb.putLong(size, newContentSize);
                } else if (field.equals(CTFStrings.TIMESTAMP_BEGIN)) {
                    bb.putLong(size, startTime);
                } else if (field.equals(CTFStrings.EVENTS_DISCARDED)) {
                    bb.putLong(size, simpleDef.getIntegerValue() - initialLost);
                } else {
                    bb.putLong(size, simpleDef.getIntegerValue());
                }
            } else if (def instanceof StringDefinition) {
                writeString(bb, def);
            } else if (def instanceof FloatDefinition) {
                writeFloat(bb, def);
            } else {
                buffer.put(new byte[(int) bitsToBytes(def.size())]);
                bb.position(buffer.position() * 8L);
            }
        }
        buffer.position((int) bitsToBytes(bb.position()));
    }

    private static void align(long align, BitBuffer input) throws CTFException {
        long mask = align - 1;
        /*
         * The alignment is a power of 2
         */
        long pos = input.position();
        if ((pos & mask) == 0) {
            return;
        }
        pos = (pos + mask) & ~mask;
        input.position(pos);
    }

    private static void writeFloat(BitBuffer bb, Definition def) throws CTFException {
        FloatDefinition floatDefinition = (FloatDefinition) def;
        double value = floatDefinition.getValue();
        FloatDeclaration declaration = floatDefinition.getDeclaration();
        int exponent = declaration.getExponent();
        int mantissa = declaration.getMantissa();
        if (mantissa == 23 && exponent == 8) {
            bb.putInt(Float.SIZE, Float.floatToIntBits((float) value));
        } else if (mantissa == 52 && exponent == 11) {
            bb.putLong(Double.SIZE, Double.doubleToLongBits(value));
        } else {
            // Inaccurate, but won't break the trace
            bb.putLong((int) floatDefinition.size(), Double.doubleToRawLongBits(value));
        }
    }

    private static void writeString(BitBuffer bb, Definition def) throws CTFException {
        StringDefinition stringDefinition = (StringDefinition) def;
        // may be encoded differently, but play it safe first.
        byte[] bytes = stringDefinition.toString().getBytes();
        try {
            bytes = stringDefinition.toString().getBytes(stringDefinition.getDeclaration().getEncoding().toString());
        } catch (UnsupportedEncodingException e) {
            Activator.log("Writing packet made an encoding error! " + e.getMessage()); //$NON-NLS-1$
        }
        bb.put(bytes);
        bb.put((byte) 0);
    }

}