/*
 * CameraUtil.java
 * Copyright (c) 2018
 * Authors: Ionut Damian, Michael Dietz, Frank Gaibler, Daniel Langerenken, Simon Flutura,
 * Vitalijs Krumins, Antonio Grieco
 * *****************************************************
 * This file is part of the Social Signal Interpretation for Java (SSJ) framework
 * developed at the Lab for Human Centered Multimedia of the University of Augsburg.
 *
 * SSJ has been inspired by the SSI (http://openssi.net) framework. SSJ is not a
 * one-to-one port of SSI to Java, it is an approximation. Nor does SSJ pretend
 * to offer SSI's comprehensive functionality and performance (this is java after all).
 * Nevertheless, SSJ borrows a lot of programming patterns from SSI.
 *
 * This library is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 3 of the License, or any later version.
 *
 * This library 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 for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this library; if not, see <http://www.gnu.org/licenses/>.
 */

package hcm.ssj.camera;

import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.media.MediaCodecInfo;
import android.media.MediaCodecList;

import java.io.File;
import java.io.FileOutputStream;
import java.util.Date;

import hcm.ssj.core.Log;
import hcm.ssj.file.FileCons;

/**
 * Utility class for the camera. <br>
 * Created by Frank Gaibler on 26.01.2016.
 */
@SuppressWarnings("deprecation")
public class CameraUtil
{
    /**
     * Returns the first codec capable of encoding the specified MIME type, or null if no
     * match was found.
     *
     * @param mimeType String
     * @return MediaCodecInfo
     */
    public static MediaCodecInfo selectCodec(String mimeType)
    {
        int numCodecs = MediaCodecList.getCodecCount();
        for (int i = 0; i < numCodecs; i++)
        {
            MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
            if (!codecInfo.isEncoder())
            {
                continue;
            }
            String[] types = codecInfo.getSupportedTypes();
            for (String type : types)
            {
                if (type.equalsIgnoreCase(mimeType))
                {
                    return codecInfo;
                }
            }
        }
        return null;
    }

    /**
     * Returns a color format that is supported by the codec and by this code.  If no
     * match is found, an exception is thrown.
     *
     * @param codecInfo MediaCodecInfo
     * @param mimeType  String
     * @return int
     */
    public static int selectColorFormat(MediaCodecInfo codecInfo, String mimeType)
    {
        MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(mimeType);
        for (int i = 0; i < capabilities.colorFormats.length; i++)
        {
            int colorFormat = capabilities.colorFormats[i];
            if (isRecognizedFormat(colorFormat))
            {
                return colorFormat;
            }
        }
        Log.e("couldn't find a good color format for " + codecInfo.getName() + " / " + mimeType);
        return 0;   // not reached
    }

    /**
     * Returns true if this is a common color format.
     *
     * @param colorFormat int
     * @return boolean
     */
    private static boolean isRecognizedFormat(int colorFormat)
    {
        switch (colorFormat)
        {
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYCrYCb:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
                return true;
            default:
                return false;
        }
    }

    /**
     * Decodes YUVNV21 color space into a regular RGB format.
     *
     * @param rgb Output array for RGB values.
     * @param yuv YUV byte data to decode.
     * @param width Width of image in pixels.
     * @param height Height of image in pixels.
     */
    public static void convertNV21ToRGB_slow(byte[] rgb, byte[] yuv, int width, int height) {
        final int frameSize = width * height;
        final int ii = 0;
        final int ij = 0;
        final int di = +1;
        final int dj = +1;

        int a = 0;
        for (int i = 0, ci = ii; i < height; ++i, ci += di) {
            for (int j = 0, cj = ij; j < width; ++j, cj += dj) {
                int y = (0xff & ((int) yuv[ci * width + cj]));
                int v = (0xff & ((int) yuv[frameSize + (ci >> 1) * width + (cj & ~1) + 0]));
                int u = (0xff & ((int) yuv[frameSize + (ci >> 1) * width + (cj & ~1) + 1]));
                y = y < 16 ? 16 : y;

                int r = (int) (1.164f * (y - 16) + 1.596f * (v - 128));
                int g = (int) (1.164f * (y - 16) - 0.813f * (v - 128) - 0.391f * (u - 128));
                int b = (int) (1.164f * (y - 16) + 2.018f * (u - 128));

                rgb[a++] = (byte)(r < 0 ? 0 : (r > 255 ? 255 : r)); // red
                rgb[a++] = (byte)(g < 0 ? 0 : (g > 255 ? 255 : g)); // green
                rgb[a++] = (byte)(b < 0 ? 0 : (b > 255 ? 255 : b)); // blue
            }
        }
    }

    public static void convertNV21ToARGBInt_slow(int[] argb, byte[] yuv, int width, int height)
    {
        final int frameSize = width * height;
        final int ii = 0;
        final int ij = 0;
        final int di = +1;
        final int dj = +1;

        int a = 0;
        for (int i = 0, ci = ii; i < height; ++i, ci += di) {
            for (int j = 0, cj = ij; j < width; ++j, cj += dj) {
                int y = (0xff & ((int) yuv[ci * width + cj]));
                int v = (0xff & ((int) yuv[frameSize + (ci >> 1) * width + (cj & ~1) + 0]));
                int u = (0xff & ((int) yuv[frameSize + (ci >> 1) * width + (cj & ~1) + 1]));
                y = y < 16 ? 16 : y;

                int r = (int) (1.164f * (y - 16) + 1.596f * (v - 128));
                int g = (int) (1.164f * (y - 16) - 0.813f * (v - 128) - 0.391f * (u - 128));
                int b = (int) (1.164f * (y - 16) + 2.018f * (u - 128));

                 r = r < 0 ? 0 : (r > 255 ? 255 : r);
                 g = g < 0 ? 0 : (g > 255 ? 255 : g);
                 b = b < 0 ? 0 : (b > 255 ? 255 : b);

                 argb[a++] = 0xff000000 | (r << 16) | (g << 8) | b;
            }
        }
    }

    /**
     * Decodes YUVNV21 color space into a regular RGB format.
     *
     * @param rgb Output array for RGB values.
     * @param yuv YUV byte data to decode.
     * @param width Width of image in pixels.
     * @param height Height of image in pixels.
     */
    public static void convertNV21ToRGB(byte[] rgb, byte[] yuv, int width, int height)
    {
        convertNV21ToRGB(rgb, yuv, width, height, true);
    }

    /**
     * Decodes YUVNV21 color space into a regular RGB format.
     *
     * @param out Output array for RGB values.
     * @param yuv YUV byte data to decode.
     * @param width Width of image in pixels.
     * @param height Height of image in pixels.
     * @param swap swap U with V (default = true)
     */
    public static void convertNV21ToRGB(byte[] out, byte[] yuv, int width, int height, boolean swap)
    {
        int sz = width * height;
        int i, j;
        int Y, Cr = 0, Cb = 0;
        int outPtr = 0;
        for (j = 0; j < height; j++)
        {
            int pixPtr = j * width;
            final int jDiv2 = j >> 1;
            for (i = 0; i < width; i++)
            {
                Y = yuv[pixPtr];
                if (Y < 0)
                    Y += 255;
                if ((i & 0x1) != 1)
                {
                    final int cOff = sz + jDiv2 * width + (i >> 1) * 2;
                    Cb = yuv[cOff + (swap ? 0 : 1)];
                    if (Cb < 0)
                    {
                        Cb += 127;
                    } else
                    {
                        Cb -= 128;
                    }
                    Cr = yuv[cOff + (swap ? 1 : 0)];
                    if (Cr < 0)
                    {
                        Cr += 127;
                    } else
                    {
                        Cr -= 128;
                    }
                }
                int R = Y + Cr + (Cr >> 2) + (Cr >> 3) + (Cr >> 5);
                if (R < 0)
                {
                    R = 0;
                } else if (R > 255)
                {
                    R = 255;
                }
                int G = Y - (Cb >> 2) + (Cb >> 4) + (Cb >> 5) - (Cr >> 1) + (Cr >> 3) + (Cr >> 4) + (Cr >> 5);
                if (G < 0)
                {
                    G = 0;
                } else if (G > 255)
                {
                    G = 255;
                }
                int B = Y + Cb + (Cb >> 1) + (Cb >> 2) + (Cb >> 6);
                if (B < 0)
                {
                    B = 0;
                } else if (B > 255)
                {
                    B = 255;
                }
                pixPtr++;
                out[outPtr++] = (byte)R;
                out[outPtr++] = (byte)G;
                out[outPtr++] = (byte)B;
            }
        }
    }

    /**
     * Decodes YUVNV21 color space into a regular RGB format.
     *
     * @param argb Output array for RGB values.
     * @param yuv YUV byte data to decode.
     * @param width Width of image in pixels.
     * @param height Height of image in pixels.
     */
    public static void convertNV21ToARGBInt(int[] argb, byte[] yuv, int width, int height)
    {
        convertNV21ToARGBInt(argb, yuv, width, height, true);
    }

    /**
     * Decodes YUVNV21 color space into a regular RGB format.
     *
     * @param out Output array for RGB values.
     * @param yuv YUV byte data to decode.
     * @param width Width of image in pixels.
     * @param height Height of image in pixels.
     * @param swap swap U with V (default = true)
     */
    public static void convertNV21ToARGBInt(int[] out, byte[] yuv, int width, int height, boolean swap)
    {
        int sz = width * height;
        int i, j;
        int Y, Cr = 0, Cb = 0;
        for (j = 0; j < height; j++)
        {
            int pixPtr = j * width;
            final int jDiv2 = j >> 1;
            for (i = 0; i < width; i++)
            {
                Y = yuv[pixPtr];
                if (Y < 0)
                    Y += 255;
                if ((i & 0x1) != 1)
                {
                    final int cOff = sz + jDiv2 * width + (i >> 1) * 2;
                    Cb = yuv[cOff + (swap ? 0 : 1)];
                    if (Cb < 0)
                    {
                        Cb += 127;
                    } else
                    {
                        Cb -= 128;
                    }
                    Cr = yuv[cOff + (swap ? 1 : 0)];
                    if (Cr < 0)
                    {
                        Cr += 127;
                    } else
                    {
                        Cr -= 128;
                    }
                }
                int R = Y + Cr + (Cr >> 2) + (Cr >> 3) + (Cr >> 5);
                if (R < 0)
                {
                    R = 0;
                } else if (R > 255)
                {
                    R = 255;
                }
                int G = Y - (Cb >> 2) + (Cb >> 4) + (Cb >> 5) - (Cr >> 1) + (Cr >> 3) + (Cr >> 4) + (Cr >> 5);
                if (G < 0)
                {
                    G = 0;
                } else if (G > 255)
                {
                    G = 255;
                }
                int B = Y + Cb + (Cb >> 1) + (Cb >> 2) + (Cb >> 6);
                if (B < 0)
                {
                    B = 0;
                } else if (B > 255)
                {
                    B = 255;
                }
                out[pixPtr++] = 0xff000000 + (B << 16) + (G << 8) + R;
            }
        }
    }

    /**
     * Saved bitmap to external storage.
     *
     * @param bitmap Bitmap to save.
     */
    public static void saveBitmap(final Bitmap bitmap) {
        final String root =
                FileCons.SSJ_EXTERNAL_STORAGE + File.separator + "previews";
        final File myDir = new File(root);

        if (!myDir.mkdirs()) {
            Log.i("Make dir failed");
        }

        final String fname = new Date().toString().replaceAll(" ", "_").replaceAll(":", "_") + ".png";
        final File file = new File(myDir, fname);
        if (file.exists()) {
            file.delete();
        }
        try {
            final FileOutputStream out = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.PNG, 99, out);
            out.flush();
            out.close();
        } catch (final Exception e) {
            Log.e("tf_ssj", "Exception!");
        }
    }

    /**
     * Returns a transformation matrix from one reference frame into another.
     * Handles cropping (if maintaining aspect ratio is desired) and rotation.
     *
     * @param srcWidth Width of source frame.
     * @param srcHeight Height of source frame.
     * @param dstWidth Width of destination frame.
     * @param dstHeight Height of destination frame.
     * @param applyRotation Amount of rotation to apply from one frame to another.
     *  Must be a multiple of 90.
     * @param maintainAspectRatio If true, will ensure that scaling in x and y remains constant,
     * cropping the image if necessary.
     * @return The transformation fulfilling the desired requirements.
     */
    public static Matrix getTransformationMatrix(
            final int srcWidth,
            final int srcHeight,
            final int dstWidth,
            final int dstHeight,
            final int applyRotation,
            final boolean maintainAspectRatio) {
        final Matrix matrix = new Matrix();

        if (applyRotation != 0) {
            // Translate so center of image is at origin.
            matrix.postTranslate(-srcWidth / 2.0f, -srcHeight / 2.0f);

            // Rotate around origin.
            matrix.postRotate(applyRotation);
        }

        // Account for the already applied rotation, if any, and then determine how
        // much scaling is needed for each axis.
        final boolean transpose = (Math.abs(applyRotation) + 90) % 180 == 0;

        final int inWidth = transpose ? srcHeight : srcWidth;
        final int inHeight = transpose ? srcWidth : srcHeight;

        // Apply scaling if necessary.
        if (inWidth != dstWidth || inHeight != dstHeight) {
            final float scaleFactorX = dstWidth / (float) inWidth;
            final float scaleFactorY = dstHeight / (float) inHeight;

            if (maintainAspectRatio) {
                // Scale by minimum factor so that dst is filled completely while
                // maintaining the aspect ratio. Some image may fall off the edge.
                final float scaleFactor = Math.max(scaleFactorX, scaleFactorY);
                matrix.postScale(scaleFactor, scaleFactor);
            } else {
                // Scale exactly to fill dst from src.
                matrix.postScale(scaleFactorX, scaleFactorY);
            }
        }

        if (applyRotation != 0) {
            // Translate back from origin centered reference to destination frame.
            matrix.postTranslate(dstWidth / 2.0f, dstHeight / 2.0f);
        }

        return matrix;
    }

    /**
     * Converts RGB bytes to RGB ints.
     *
     * @param rgbBytes RGB color bytes.
     * @param width width
     * @param height height
     * @return RGB color integers.
     */
    public static int[] decodeBytes(byte[] rgbBytes, int width, int height)
    {
        int[] rgb = new int[width * height];

        for (int i = 0; i < width * height; i++)
        {
            int r = rgbBytes[i * 3];
            int g = rgbBytes[i * 3 + 1];
            int b = rgbBytes[i * 3 + 2];

            if (r < 0)
                r += 256;
            if (g < 0)
                g += 256;
            if (b < 0)
                b += 256;

            rgb[i] = 0xff000000 | (r << 16) | (g << 8) | b;
        }

        return rgb;
    }

    /**
     * Converts bitmap to corresponding byte array and writes it
     * to the output buffer.
     *
     * @param bitmap Bitmap to convert to byte array.
     * @param intOutput Integer output buffer
     * @param byteOutput Byte output buffer.
     */
    public static void convertBitmapToByteArray(Bitmap bitmap, int[] intOutput, byte[] byteOutput)
    {
        bitmap.getPixels(intOutput, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());

        for (int i = 0; i < bitmap.getWidth() * bitmap.getHeight(); ++i)
        {
            final int pixel = intOutput[i];
            byteOutput[i * 3] = (byte)((pixel >> 16) & 0xFF);
            byteOutput[i * 3 + 1] = (byte)((pixel >> 8) & 0xFF);
            byteOutput[i * 3 + 2] = (byte)(pixel & 0xFF);
        }
    }

	public static void convertRGBToARGBInt(int[] argb, byte[] rgb, int width, int height)
    {
        int cnt_out = 0;
        int cnt_in = 0;
        int r,g,b;

        for(int i = 0; i < width; i++)
        {
            for (int j = 0; j < height; j++)
            {
                r = rgb[cnt_in++];
                g = rgb[cnt_in++];
                b = rgb[cnt_in++];

                if (r < 0) r += 256;
                if (g < 0) g += 256;
                if (b < 0) b += 256;

                argb[cnt_out++] = 0xff000000 | (r << 16) | (g << 8) | b;
            }
        }
    }

    /**
     * Decodes YUV frame to a RGB buffer
     *
     * @param rgba     int[]
     * @param yuv420sp byte[]
     * @param width    width
     * @param height   height
     */
    public static void decodeYV12PackedSemi(int[] rgba, byte[] yuv420sp, int width, int height)
    {
        //@todo untested
        final int frameSize = width * height;
        int r, g, b, y1192, y, i, uvp, u, v;
        for (int j = 0, yp = 0; j < height; j++)
        {
            uvp = frameSize + (j >> 1) * width;
            u = 0;
            v = 0;
            for (i = 0; i < width; i++, yp++)
            {
                y = (0xff & ((int) yuv420sp[yp])) - 16;
                if (y < 0)
                    y = 0;
                if ((i & 1) == 0)
                {
                    v = (0xff & yuv420sp[uvp++]) - 128;
                    u = (0xff & yuv420sp[uvp++]) - 128;
                }
                y1192 = 1192 * y;
                r = (y1192 + 1634 * v);
                g = (y1192 - 833 * v - 400 * u);
                b = (y1192 + 2066 * u);
                //
                r = Math.max(0, Math.min(r, 262143));
                g = Math.max(0, Math.min(g, 262143));
                b = Math.max(0, Math.min(b, 262143));
                // rgb[yp] = 0xff000000 | ((r << 6) & 0xff0000) | ((g >> 2) &
                // 0xff00) | ((b >> 10) & 0xff);
                // rgba, divide 2^10 ( >> 10)
                rgba[yp] = ((r << 14) & 0xff000000) | ((g << 6) & 0xff0000)
                        | ((b >> 2) | 0xff00);
            }
        }
    }
}
