/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * 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.
 */

//#define LOG_NDEBUG 0
#define LOG_TAG "EmulatedCamera_Exif"
#include <log/log.h>
#include <cutils/properties.h>

#include <inttypes.h>
#include <math.h>
#include <stdint.h>

#include "Exif.h"
#include <libexif/exif-data.h>
#include <libexif/exif-entry.h>
#include <libexif/exif-ifd.h>
#include <libexif/exif-tag.h>

#include <string>
#include <vector>

#include "fake-pipeline2/Sensor.h"

// For GPS timestamping we want to ensure we use a 64-bit time_t, 32-bit
// platforms have time64_t but 64-bit platforms do not.
#if defined(__LP64__)
#include <time.h>
using Timestamp = time_t;
#define TIMESTAMP_TO_TM(timestamp, tm) gmtime_r(timestamp, tm)
#else
#include <time64.h>
using Timestamp = time64_t;
#define TIMESTAMP_TO_TM(timestamp, tm) gmtime64_r(timestamp, tm)
#endif

namespace android {

// A prefix that is used for tags with the "undefined" format to indicate that
// the contents are ASCII encoded. See the user comment section of the EXIF spec
// for more details http://www.exif.org/Exif2-2.PDF
static const unsigned char kAsciiPrefix[] = {
    0x41, 0x53, 0x43, 0x49, 0x49, 0x00, 0x00, 0x00 // "ASCII\0\0\0"
};

// Remove an existing EXIF entry from |exifData| if it exists. This is useful
// when replacing existing data, it's easier to just remove the data and
// re-allocate it than to adjust the amount of allocated data.
static void removeExistingEntry(ExifData* exifData, ExifIfd ifd, int tag) {
    ExifEntry* entry = exif_content_get_entry(exifData->ifd[ifd],
                                              static_cast<ExifTag>(tag));
    if (entry) {
        exif_content_remove_entry(exifData->ifd[ifd], entry);
    }
}

static ExifEntry* allocateEntry(int tag,
                                ExifFormat format,
                                unsigned int numComponents) {
    ExifMem* mem = exif_mem_new_default();
    ExifEntry* entry = exif_entry_new_mem(mem);

    unsigned int size = numComponents * exif_format_get_size(format);
    entry->data = reinterpret_cast<unsigned char*>(exif_mem_alloc(mem, size));
    entry->size = size;
    entry->tag = static_cast<ExifTag>(tag);
    entry->components = numComponents;
    entry->format = format;

    exif_mem_unref(mem);
    return entry;
}

// Create an entry and place it in |exifData|, the entry is initialized with an
// array of floats from |values|
template<size_t N>
static bool createEntry(ExifData* exifData,
                        ExifIfd ifd,
                        int tag,
                        const float (&values)[N],
                        float denominator = 1000.0) {
    removeExistingEntry(exifData, ifd, tag);
    ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
    ExifEntry* entry = allocateEntry(tag, EXIF_FORMAT_RATIONAL, N);
    exif_content_add_entry(exifData->ifd[ifd], entry);
    unsigned int rationalSize = exif_format_get_size(EXIF_FORMAT_RATIONAL);
    for (size_t i = 0; i < N; ++i) {
        ExifRational rational = {
            static_cast<uint32_t>(values[i] * denominator),
            static_cast<uint32_t>(denominator)
        };

        exif_set_rational(&entry->data[i * rationalSize], byteOrder, rational);
    }

    // Unref entry after changing owner to the ExifData struct
    exif_entry_unref(entry);
    return true;
}

// Create an entry with a single float |value| in it and place it in |exifData|
static bool createEntry(ExifData* exifData,
                        ExifIfd ifd,
                        int tag,
                        const float value,
                        float denominator = 1000.0) {
    float values[1] = { value };
    // Recycling functions is good for the environment
    return createEntry(exifData, ifd, tag, values, denominator);
}

// Create an entry and place it in |exifData|, the entry contains the raw data
// pointed to by |data| of length |size|.
static bool createEntry(ExifData* exifData,
                        ExifIfd ifd,
                        int tag,
                        const unsigned char* data,
                        size_t size,
                        ExifFormat format = EXIF_FORMAT_UNDEFINED) {
    removeExistingEntry(exifData, ifd, tag);
    ExifEntry* entry = allocateEntry(tag, format, size);
    memcpy(entry->data, data, size);
    exif_content_add_entry(exifData->ifd[ifd], entry);
    // Unref entry after changing owner to the ExifData struct
    exif_entry_unref(entry);
    return true;
}

// Create an entry and place it in |exifData|, the entry is initialized with
// the string provided in |value|
static bool createEntry(ExifData* exifData,
                        ExifIfd ifd,
                        int tag,
                        const char* value) {
    unsigned int length = strlen(value) + 1;
    const unsigned char* data = reinterpret_cast<const unsigned char*>(value);
    return createEntry(exifData, ifd, tag, data, length, EXIF_FORMAT_ASCII);
}

// Create an entry and place it in |exifData|, the entry is initialized with a
// single byte in |value|
//static bool createEntry(ExifData* exifData,
//                        ExifIfd ifd,
//                        int tag,
//                        uint8_t value) {
//    return createEntry(exifData, ifd, tag, &value, 1, EXIF_FORMAT_BYTE);
//}

// Create an entry and place it in |exifData|, the entry is default initialized
// by the exif library based on |tag|
static bool createEntry(ExifData* exifData,
                        ExifIfd ifd,
                        int tag) {
    removeExistingEntry(exifData, ifd, tag);
    ExifEntry* entry = exif_entry_new();
    exif_content_add_entry(exifData->ifd[ifd], entry);
    exif_entry_initialize(entry, static_cast<ExifTag>(tag));
    // Unref entry after changing owner to the ExifData struct
    exif_entry_unref(entry);
    return true;
}

// Create an entry with a single EXIF LONG (32-bit value) and place it in
// |exifData|.
static bool createEntry(ExifData* exifData,
                        ExifIfd ifd,
                        int tag,
                        int value) {
    removeExistingEntry(exifData, ifd, tag);
    ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
    ExifEntry* entry = allocateEntry(tag, EXIF_FORMAT_LONG, 1);
    exif_content_add_entry(exifData->ifd[ifd], entry);
    exif_set_long(entry->data, byteOrder, value);

    // Unref entry after changing owner to the ExifData struct
    exif_entry_unref(entry);
    return true;
}

// Create an entry with a single EXIF SHORT (16-bit value) and place it in
// |exifData|.
static bool createEntry(ExifData* exifData,
                        ExifIfd ifd,
                        int tag,
                        uint16_t value) {
    removeExistingEntry(exifData, ifd, tag);
    ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
    ExifEntry* entry = allocateEntry(tag, EXIF_FORMAT_SHORT, 1);
    exif_content_add_entry(exifData->ifd[ifd], entry);
    exif_set_short(entry->data, byteOrder, value);

    // Unref entry after changing owner to the ExifData struct
    exif_entry_unref(entry);
    return true;
}

static bool getCameraParam(const CameraParameters& parameters,
                           const char* parameterKey,
                           const char** outValue) {
    const char* value = parameters.get(parameterKey);
    if (value) {
        *outValue = value;
        return true;
    }
    return false;
}

static bool getCameraParam(const CameraParameters& parameters,
                           const char* parameterKey,
                           float* outValue) {
    const char* value = parameters.get(parameterKey);
    if (value) {
        *outValue = parameters.getFloat(parameterKey);
        return true;
    }
    return false;
}

static bool getCameraParam(const CameraParameters& parameters,
                           const char* parameterKey,
                           int64_t* outValue) {
    const char* value = parameters.get(parameterKey);
    if (value) {
        char dummy = 0;
        // Attempt to scan an extra character and then make sure it was not
        // scanned by checking that the return value indicates only one item.
        // This way we fail on any trailing characters
        if (sscanf(value, "%" SCNd64 "%c", outValue, &dummy) == 1) {
            return true;
        }
    }
    return false;
}

// Convert a GPS coordinate represented as a decimal degree value to sexagesimal
// GPS coordinates comprised of <degrees> <minutes>' <seconds>"
static void convertGpsCoordinate(float degrees, float (*result)[3]) {
    float absDegrees = fabs(degrees);
    // First value is degrees without any decimal digits
    (*result)[0] = floor(absDegrees);

    // Subtract degrees so we only have the fraction left, then multiply by
    // 60 to get the minutes
    float minutes = (absDegrees - (*result)[0]) * 60.0f;
    (*result)[1] = floor(minutes);

    // Same thing for seconds but here we store seconds with the fraction
    float seconds = (minutes - (*result)[1]) * 60.0f;
    (*result)[2] = seconds;
}

// Convert a UNIX epoch timestamp to a timestamp comprised of three floats for
// hour, minute and second, and a date part that is represented as a string.
static bool convertTimestampToTimeAndDate(int64_t timestamp,
                                          float (*timeValues)[3],
                                          std::string* date) {
    Timestamp time = timestamp;
    struct tm utcTime;
    if (TIMESTAMP_TO_TM(&time, &utcTime) == nullptr) {
        ALOGE("Could not decompose timestamp into components");
        return false;
    }
    (*timeValues)[0] = utcTime.tm_hour;
    (*timeValues)[1] = utcTime.tm_min;
    (*timeValues)[2] = utcTime.tm_sec;

    char buffer[64] = {};
    if (strftime(buffer, sizeof(buffer), "%Y:%m:%d", &utcTime) == 0) {
        ALOGE("Could not construct date string from timestamp");
        return false;
    }
    *date = buffer;
    return true;
}

// Convert and store key values in CameraMetadata
static void convertToMetadata(const CameraParameters& src, CameraMetadata& dst) {
    int64_t longValue;
    float floatValue, floatGps[3];
    const char* stringValue;

    // Orientation
    if (getCameraParam(src,
                       CameraParameters::KEY_ROTATION,
                       &longValue)) {
        int32_t degrees = (int32_t)longValue;
        dst.update(ANDROID_JPEG_ORIENTATION, &degrees, 1);
    }
    // Focal length
    if (getCameraParam(src,
                       CameraParameters::KEY_FOCAL_LENGTH,
                       &floatValue)) {
        dst.update(ANDROID_LENS_FOCAL_LENGTH, &floatValue, 1);
    }
    // GPS latitude longitude and altitude
    if (getCameraParam(src,
                       CameraParameters::KEY_GPS_LATITUDE,
                       &floatGps[0]) &&
        getCameraParam(src,
                       CameraParameters::KEY_GPS_LONGITUDE,
                       &floatGps[1]) &&
        getCameraParam(src,
                       CameraParameters::KEY_GPS_ALTITUDE,
                       &floatGps[2])) {
        double gps[3];
        gps[0] = (double)floatGps[0];
        gps[1] = (double)floatGps[1];
        gps[2] = (double)floatGps[2];
        dst.update(ANDROID_JPEG_GPS_COORDINATES, gps, 3);
    }
    // GPS timestamp and datestamp
    if (getCameraParam(src,
                       CameraParameters::KEY_GPS_TIMESTAMP,
                       &longValue)) {
        dst.update(ANDROID_JPEG_GPS_TIMESTAMP, &longValue, 1);
    }
    // GPS processing method
    if (getCameraParam(src,
                       CameraParameters::KEY_GPS_PROCESSING_METHOD,
                       &stringValue)) {
        dst.update(ANDROID_JPEG_GPS_PROCESSING_METHOD, (unsigned char*)stringValue,
                   strlen(stringValue));
    }
}

// Create Exif data common for both HAL1 and HAL3
static ExifData* createExifDataCommon(const CameraMetadata& params, int width, int height) {
    ExifData* exifData = exif_data_new();

    exif_data_set_option(exifData, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
    exif_data_set_data_type(exifData, EXIF_DATA_TYPE_COMPRESSED);
    exif_data_set_byte_order(exifData, EXIF_BYTE_ORDER_INTEL);

    // Create mandatory exif fields and set their default values
    exif_data_fix(exifData);

    float triplet[3];
    const char* stringValue;
    int32_t degrees;
    float focalLength;

    // Datetime, creating and initializing a datetime tag will automatically
    // set the current date and time in the tag so just do that.
    createEntry(exifData, EXIF_IFD_0, EXIF_TAG_DATE_TIME);

    // Make and model
    std::vector<char> prop(PROPERTY_VALUE_MAX);
    property_get("ro.product.manufacturer", &prop[0], "");
    createEntry(exifData, EXIF_IFD_0, EXIF_TAG_MAKE, &prop[0]);
    property_get("ro.product.model", &prop[0], "");
    createEntry(exifData, EXIF_IFD_0, EXIF_TAG_MODEL, &prop[0]);

    // Width and height
    if (width > 0 && height > 0) {
        createEntry(exifData, EXIF_IFD_EXIF,
                    EXIF_TAG_PIXEL_X_DIMENSION, width);
        createEntry(exifData, EXIF_IFD_EXIF,
                    EXIF_TAG_PIXEL_Y_DIMENSION, height);
    }

    camera_metadata_ro_entry_t entry;
    entry = params.find(ANDROID_LENS_FOCAL_LENGTH);
    focalLength = (entry.count > 0) ? entry.data.f[0] : 5.0f;
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH, focalLength);
    entry = params.find(ANDROID_JPEG_ORIENTATION);
    degrees = (entry.count > 0) ? entry.data.i32[0] : 0;
    ALOGV("degrees %d focalLength %f", degrees, focalLength);
    enum {
        EXIF_ROTATE_CAMERA_CW0 = 1,
        EXIF_ROTATE_CAMERA_CW90 = 6,
        EXIF_ROTATE_CAMERA_CW180 = 3,
        EXIF_ROTATE_CAMERA_CW270 = 8,
    };
    uint16_t exifOrien = 1;
    switch (degrees) {
        case 0:
            exifOrien = EXIF_ROTATE_CAMERA_CW0;
            break;
        case 90:
            exifOrien = EXIF_ROTATE_CAMERA_CW90;
            break;
        case 180:
            exifOrien = EXIF_ROTATE_CAMERA_CW180;
            break;
        case 270:
            exifOrien = EXIF_ROTATE_CAMERA_CW270;
            break;
    }
    createEntry(exifData, EXIF_IFD_0, EXIF_TAG_ORIENTATION, exifOrien);

    // GPS information
    entry = params.find(ANDROID_JPEG_GPS_COORDINATES);
    if (entry.count > 0) {
        ALOGV("Latitude %f Longitude %f Altitude %f", entry.data.d[0], entry.data.d[1], entry.data.d[2]);
        convertGpsCoordinate(entry.data.d[0], &triplet);
        createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE, triplet);

        const char* ref = entry.data.d[0] < 0.0f ? "S" : "N";
        createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF, ref);

        // GPS longitude and reference, reference indicates sign, store unsigned
        convertGpsCoordinate(entry.data.d[1], &triplet);
        createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE, triplet);

        ref = entry.data.d[1] < 0.0f ? "W" : "E";
        createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF, ref);

        createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE,
                    static_cast<float>(fabs(entry.data.d[2])));
        int ref1;
        // 1 indicated below sea level, 0 indicates above sea level
        ref1 = entry.data.d[2] < 0.0f ? 1 : 0;
        createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE_REF, ref1);
    }

    int64_t timestamp = 0;
    entry = params.find(ANDROID_JPEG_GPS_TIMESTAMP);
    if (entry.count > 0) {
        timestamp = entry.data.i64[0];
        std::string date;
        if (convertTimestampToTimeAndDate(timestamp, &triplet, &date)) {
            createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_TIME_STAMP,
                        triplet, 1.0f);
            createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_DATE_STAMP,
                        date.c_str());
        }
    }

    // GPS processing method
    entry = params.find(ANDROID_JPEG_GPS_PROCESSING_METHOD);
    if (entry.count > 0) {
        stringValue = (const char*)entry.data.u8;
        ALOGV("ANDROID_JPEG_GPS_PROCESSING_METHOD(len=%d) %s", entry.count, stringValue);
        std::vector<unsigned char> data;
        // Because this is a tag with an undefined format it has to be prefixed
        // with the encoding type. Insert an ASCII prefix first, then the
        // actual string. Undefined tags do not have to be null terminated.
        data.insert(data.end(),
                    std::begin(kAsciiPrefix),
                    std::end(kAsciiPrefix));
        data.insert(data.end(), stringValue, stringValue + entry.count);
        createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_PROCESSING_METHOD,
                    &data[0], data.size());
    }
    return exifData;
}

ExifData* createExifData(const CameraMetadata& params, int width, int height) {
    ExifData* exifData = createExifDataCommon(params, width, height);
    // Exposure Time
    camera_metadata_ro_entry entry;
    entry= params.find(ANDROID_SENSOR_EXPOSURE_TIME);
    int64_t exposureTimesNs =
        (entry.count > 0) ? entry.data.i64[0] : Sensor::kExposureTimeRange[0];
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME,
                exposureTimesNs/1000000000.0f, 1000000000);
    // Aperture
    entry = params.find(ANDROID_LENS_APERTURE);
    float aperture = (entry.count > 0) ? entry.data.f[0] : 2.8;
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_FNUMBER, aperture);
    // Flash, 0 for off
    entry = params.find(ANDROID_FLASH_MODE);
    uint16_t flash = (entry.count > 0) ? entry.data.i32[0] : 0;
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_FLASH, flash);
    // White balance, 0 for auto, 1 for manual.
    entry = params.find(ANDROID_CONTROL_AWB_MODE);
    uint16_t awb = 1;
    if (entry.count > 0 && entry.data.i32[0] == ANDROID_CONTROL_AWB_MODE_AUTO) {
        awb = 0;
    }
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE, awb);
    // ISO
    entry = params.find(ANDROID_SENSOR_SENSITIVITY);
    int isoSpeedRating = (entry.count > 0) ?
        entry.data.i32[0] : Sensor::kSensitivityRange[0];
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS,
                (uint16_t)isoSpeedRating);
    // Date and time
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED);
    // Sub second time
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME, "0");
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME_ORIGINAL, "0");
    createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME_DIGITIZED, "0");

    return exifData;
}

ExifData* createExifData(const CameraParameters& params) {
    int width = -1, height = -1;
    CameraMetadata cameraMetadata;
    convertToMetadata(params, cameraMetadata);
    params.getPictureSize(&width, &height);
    ExifData* exifData =  createExifDataCommon(cameraMetadata, width, height);
    return exifData;
}

void freeExifData(ExifData* exifData) {
    exif_data_free(exifData);
}

}  // namespace android