#include <libavutil/mastering_display_metadata.h>
#ifndef _DRM_MODE_H
/**
 * struct hdr_metadata_infoframe - HDR Metadata Infoframe Data.
 *
 * HDR Metadata Infoframe as per CTA 861.G spec. This is expected
 * to match exactly with the spec.
 *
 * Userspace is expected to pass the metadata information as per
 * the format described in this structure.
 */
struct hdr_metadata_infoframe {
    /**
     * @eotf: Electro-Optical Transfer Function (EOTF)
     * used in the stream.
     */
    __u8 eotf;
    /**
     * @metadata_type: Static_Metadata_Descriptor_ID.
     */
    __u8 metadata_type;
    /**
     * @display_primaries: Color Primaries of the Data.
     * These are coded as unsigned 16-bit values in units of
     * 0.00002, where 0x0000 represents zero and 0xC350
     * represents 1.0000.
     * @display_primaries.x: X cordinate of color primary.
     * @display_primaries.y: Y cordinate of color primary.
     */
    struct {
        __u16 x, y;
    } display_primaries[3];
    /**
     * @white_point: White Point of Colorspace Data.
     * These are coded as unsigned 16-bit values in units of
     * 0.00002, where 0x0000 represents zero and 0xC350
     * represents 1.0000.
     * @white_point.x: X cordinate of whitepoint of color primary.
     * @white_point.y: Y cordinate of whitepoint of color primary.
     */
    struct {
        __u16 x, y;
    } white_point;
    /**
     * @max_display_mastering_luminance: Max Mastering Display Luminance.
     * This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
     * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
     */
    __u16 max_display_mastering_luminance;
    /**
     * @min_display_mastering_luminance: Min Mastering Display Luminance.
     * This value is coded as an unsigned 16-bit value in units of
     * 0.0001 cd/m2, where 0x0001 represents 0.0001 cd/m2 and 0xFFFF
     * represents 6.5535 cd/m2.
     */
    __u16 min_display_mastering_luminance;
    /**
     * @max_cll: Max Content Light Level.
     * This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
     * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
     */
    __u16 max_cll;
    /**
     * @max_fall: Max Frame Average Light Level.
     * This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
     * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
     */
    __u16 max_fall;
};

/**
 * struct hdr_output_metadata - HDR output metadata
 *
 * Metadata Information to be passed from userspace
 */
struct hdr_output_metadata {
    /**
     * @metadata_type: Static_Metadata_Descriptor_ID.
     */
    __u32 metadata_type;
    /**
     * @hdmi_metadata_type1: HDR Metadata Infoframe.
     */
    union {
        struct hdr_metadata_infoframe hdmi_metadata_type1;
    };
};
#endif

enum hdr_metadata_eotf {
    EOTF_TRADITIONAL_GAMMA_SDR,
    EOTF_TRADITIONAL_GAMMA_HDR,
    EOTF_ST2084,
    EOTF_HLG,
};

enum metadata_id {
    METADATA_TYPE1,
};

void weston_hdr_metadata(void *data, uint16_t display_primary_r_x, uint16_t display_primary_r_y,
                         uint16_t display_primary_g_x, uint16_t display_primary_g_y, uint16_t display_primary_b_x,
                         uint16_t display_primary_b_y, uint16_t white_point_x, uint16_t white_point_y,
                         uint16_t min_luminance, uint16_t max_luminance, uint16_t max_cll, uint16_t max_fall,
                         enum hdr_metadata_eotf eotf) {
    uint8_t *data8;
    uint16_t *data16;

    data8 = data;

    *data8++ = eotf;
    *data8++ = METADATA_TYPE1;

    data16 = (void *)data8;

    *data16++ = display_primary_r_x;
    *data16++ = display_primary_r_y;
    *data16++ = display_primary_g_x;
    *data16++ = display_primary_g_y;
    *data16++ = display_primary_b_x;
    *data16++ = display_primary_b_y;
    *data16++ = white_point_x;
    *data16++ = white_point_y;

    *data16++ = max_luminance;
    *data16++ = min_luminance;
    *data16++ = max_cll;
    *data16++ = max_fall;
}

struct weston_vector {
    float f[4];
};

struct weston_colorspace {
    struct weston_vector r, g, b;
    struct weston_vector whitepoint;
    const char *name;
    const char *whitepoint_name;
};

struct weston_colorspace hdr10;

static const struct weston_colorspace bt470m = {
    .r = {{
        0.670f,
        0.330f,
    }},
    .g = {{
        0.210f,
        0.710f,
    }},
    .b = {{
        0.140f,
        0.080f,
    }},
    .whitepoint = {{
        0.3101f,
        0.3162f,
    }},
    .name = "BT.470 M",
    .whitepoint_name = "C",
};

static const struct weston_colorspace bt470bg = {
    .r = {{
        0.640f,
        0.330f,
    }},
    .g = {{
        0.290f,
        0.600f,
    }},
    .b = {{
        0.150f,
        0.060f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "BT.470 B/G",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace smpte170m = {
    .r = {{
        0.630f,
        0.340f,
    }},
    .g = {{
        0.310f,
        0.595f,
    }},
    .b = {{
        0.155f,
        0.070f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "SMPTE 170M",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace smpte240m = {
    .r = {{
        0.630f,
        0.340f,
    }},
    .g = {{
        0.310f,
        0.595f,
    }},
    .b = {{
        0.155f,
        0.070f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "SMPTE 240M",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace bt709 = {
    .r = {{
        0.640f,
        0.330f,
    }},
    .g = {{
        0.300f,
        0.600f,
    }},
    .b = {{
        0.150f,
        0.060f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "BT.709",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace bt2020 = {
    .r = {{
        0.708f,
        0.292f,
    }},
    .g = {{
        0.170f,
        0.797f,
    }},
    .b = {{
        0.131f,
        0.046f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "BT.2020",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace srgb = {
    .r = {{
        0.640f,
        0.330f,
    }},
    .g = {{
        0.300f,
        0.600f,
    }},
    .b = {{
        0.150f,
        0.060f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "sRGB",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace adobergb = {
    .r = {{
        0.640f,
        0.330f,
    }},
    .g = {{
        0.210f,
        0.710f,
    }},
    .b = {{
        0.150f,
        0.060f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "AdobeRGB",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace dci_p3 = {
    .r = {{
        0.680f,
        0.320f,
    }},
    .g = {{
        0.265f,
        0.690f,
    }},
    .b = {{
        0.150f,
        0.060f,
    }},
    .whitepoint = {{
        0.3127f,
        0.3290f,
    }},
    .name = "DCI-P3 D65",
    .whitepoint_name = "D65",
};

static const struct weston_colorspace prophotorgb = {
    .r = {{
        0.7347f,
        0.2653f,
    }},
    .g = {{
        0.1596f,
        0.8404f,
    }},
    .b = {{
        0.0366f,
        0.0001f,
    }},
    .whitepoint = {{.3457, .3585}},
    .name = "ProPhoto RGB",
    .whitepoint_name = "D50",
};

static const struct weston_colorspace ciergb = {
    .r = {{
        0.7347f,
        0.2653f,
    }},
    .g = {{
        0.2738f,
        0.7174f,
    }},
    .b = {{
        0.1666f,
        0.0089f,
    }},
    .whitepoint = {{
        1.0f / 3.0f,
        1.0f / 3.0f,
    }},
    .name = "CIE RGB",
    .whitepoint_name = "E",
};

static const struct weston_colorspace ciexyz = {
    .r = {{
        1.0f,
        0.0f,
    }},
    .g = {{
        0.0f,
        1.0f,
    }},
    .b = {{
        0.0f,
        0.0f,
    }},
    .whitepoint = {{
        1.0f / 3.0f,
        1.0f / 3.0f,
    }},
    .name = "CIE XYZ",
    .whitepoint_name = "E",
};

const struct weston_colorspace ap0 = {
    .r = {{
        0.7347f,
        0.2653f,
    }},
    .g = {{
        0.0000f,
        1.0000f,
    }},
    .b = {{
        0.0001f,
        -0.0770f,
    }},
    .whitepoint = {{
        .32168f,
        .33767f,
    }},
    .name = "ACES primaries #0",
    .whitepoint_name = "D60",
};

const struct weston_colorspace ap1 = {
    .r = {{
        0.713f,
        0.393f,
    }},
    .g = {{
        0.165f,
        0.830f,
    }},
    .b = {{
        0.128f,
        0.044f,
    }},
    .whitepoint = {{
        0.32168f,
        0.33767f,
    }},
    .name = "ACES primaries #1",
    .whitepoint_name = "D60",
};

static const struct weston_colorspace *const colorspaces[] = {
    &bt470m,   &bt470bg, &smpte170m,   &smpte240m, &bt709,  &bt2020, &srgb,
    &adobergb, &dci_p3,  &prophotorgb, &ciergb,    &ciexyz, &ap0,    &ap1,
};
#define ARRAY_LENGTH(a) (sizeof(a) / sizeof(a)[0])
const struct weston_colorspace *weston_colorspace_lookup(const char *name) {
    unsigned i;

    if (!name)
        return NULL;

    for (i = 0; i < ARRAY_LENGTH(colorspaces); i++) {
        const struct weston_colorspace *c = colorspaces[i];

        if (!strcmp(c->name, name))
            return c;
    }

    return NULL;
}

static int cleanup = 0;

static uint16_t encode_xyy(float xyy) { return xyy * 50000; }
static AVMasteringDisplayMetadata md_save = {0};
static AVContentLightMetadata ld_save = {0};
static void set_hdr_metadata(int color, int trc, AVFrameSideData *sd1, AVFrameSideData *sd2) {
    drmModeAtomicReqPtr ModeReq;
    struct weston_colorspace *cs;
    enum hdr_metadata_eotf eotf;
    struct hdr_output_metadata data;
    int ret, MaxCLL = 1500, MaxFALL = 400;
    int max_lum = 4000, min_lum = 0050;
    struct AVMasteringDisplayMetadata *md = NULL;
    struct AVContentLightMetadata *ld = NULL;

    // clean up FFMEPG stuff
    if (trc == AVCOL_TRC_BT2020_10)
        trc = AVCOL_TRC_ARIB_STD_B67;

    if ((old_color == color && old_trc == trc && !sd1 && !sd2) || !render->hdr_metadata)
        return; // nothing to do

    if (sd1)
        md = sd1->data;

    if (sd2)
        ld = sd2->data;

    if (md && !memcmp(md, &md_save, sizeof(md_save)))
        if (ld && !memcmp(ld, &ld_save, sizeof(ld_save))) {
            return;
        } else if (ld && !memcmp(ld, &ld_save, sizeof(ld_save))) {
            return;
        }

    if (ld)
        memcpy(&ld_save, ld, sizeof(ld_save));
    if (md)
        memcpy(&md_save, md, sizeof(md_save));

    Debug(3, "Update HDR to TRC %d color %d\n", trc, color);

    old_color = color;
    old_trc = trc;

    if (VulkanTargetColorSpace != 3) { // no HDR TV
        m_need_modeset = 1;            // change in colorsettings
        return;
    }

    if (render->hdr_blob_id)
        drmModeDestroyPropertyBlob(render->fd_drm, render->hdr_blob_id);

    switch (trc) {
        case AVCOL_TRC_BT709:       // 1
        case AVCOL_TRC_UNSPECIFIED: // 2
            eotf = EOTF_TRADITIONAL_GAMMA_SDR;
            break;
        case AVCOL_TRC_BT2020_10: // 14
        case AVCOL_TRC_BT2020_12:
        case AVCOL_TRC_ARIB_STD_B67: // 18 HLG
            eotf = EOTF_HLG;
            break;
        case AVCOL_TRC_SMPTE2084: // 16
            eotf = EOTF_ST2084;
            break;
        default:
            eotf = EOTF_TRADITIONAL_GAMMA_SDR;
            break;
    }

    switch (color) {
        case AVCOL_PRI_BT709:       // 1
        case AVCOL_PRI_UNSPECIFIED: // 2
            cs = weston_colorspace_lookup("BT.709");
            break;
        case AVCOL_PRI_BT2020: // 9
            cs = weston_colorspace_lookup("BT.2020");
            break;
        case AVCOL_PRI_BT470BG:                          // 5
            cs = weston_colorspace_lookup("BT.470 B/G"); // BT.601
            break;
        default:
            cs = weston_colorspace_lookup("BT.709");
            break;
    }

    if (md) { // we got Metadata
        if (md->has_primaries) {
            Debug(3,
                  "Mastering Display Metadata,\n has_primaries:%d has_luminance:%d \n"
                  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) \n"
                  "min_luminance=%f, max_luminance=%f\n",
                  md->has_primaries, md->has_luminance, av_q2d(md->display_primaries[0][0]),
                  av_q2d(md->display_primaries[0][1]), av_q2d(md->display_primaries[1][0]),
                  av_q2d(md->display_primaries[1][1]), av_q2d(md->display_primaries[2][0]),
                  av_q2d(md->display_primaries[2][1]), av_q2d(md->white_point[0]), av_q2d(md->white_point[1]),
                  av_q2d(md->min_luminance), av_q2d(md->max_luminance));

            cs = &hdr10;
            cs->r.f[0] = (float)md->display_primaries[0][0].num / (float)md->display_primaries[0][0].den;
            cs->r.f[1] = (float)md->display_primaries[0][1].num / (float)md->display_primaries[0][1].den;
            cs->g.f[0] = (float)md->display_primaries[1][0].num / (float)md->display_primaries[1][0].den;
            cs->g.f[1] = (float)md->display_primaries[1][1].num / (float)md->display_primaries[1][1].den;
            cs->b.f[0] = (float)md->display_primaries[2][0].num / (float)md->display_primaries[2][0].den;
            cs->b.f[1] = (float)md->display_primaries[2][1].num / (float)md->display_primaries[2][1].den;
            cs->whitepoint.f[0] = (float)md->white_point[0].num / (float)md->white_point[0].den;
            cs->whitepoint.f[1] = (float)md->white_point[1].num / (float)md->white_point[1].den;
        }
        if (md->has_luminance) {
            max_lum = av_q2d(md->max_luminance);
            min_lum = av_q2d(md->min_luminance) * 10000;
            printf("max_lum %d min_lum %d\n", max_lum, min_lum);
        }
    }
    if (ld) {
        Debug(3, "Has MaxCLL %d MaxFALL %d\n", ld->MaxCLL, ld->MaxFALL);
        MaxCLL = ld->MaxCLL;
        MaxFALL = ld->MaxFALL;
    }
    data.metadata_type = 7; // ????????????????????????
    weston_hdr_metadata(&data.hdmi_metadata_type1, encode_xyy(cs->r.f[0]), encode_xyy(cs->r.f[1]),
                        encode_xyy(cs->g.f[0]), encode_xyy(cs->g.f[1]), encode_xyy(cs->b.f[0]), encode_xyy(cs->b.f[1]),
                        encode_xyy(cs->whitepoint.f[0]), encode_xyy(cs->whitepoint.f[1]),
                        max_lum, // max_display_mastering_luminance
                        min_lum, // min_display_mastering_luminance
                        MaxCLL,  // Maximum Content Light Level (MaxCLL)
                        MaxFALL, // Maximum Frame-Average Light Level (MaxFALL)
                        eotf);

    ret = drmModeCreatePropertyBlob(render->fd_drm, &data, sizeof(data), &render->hdr_blob_id);
    if (ret) {
        printf("DRM: HDR metadata: failed blob create \n");
        render->hdr_blob_id = 0;
        return;
    }

    ret = drmModeConnectorSetProperty(render->fd_drm, render->connector_id, render->hdr_metadata, render->hdr_blob_id);
    if (ret) {
        printf("DRM: HDR metadata: failed property set %d\n", ret);

        if (render->hdr_blob_id)
            drmModeDestroyPropertyBlob(render->fd_drm, render->hdr_blob_id);
        render->hdr_blob_id = 0;
        return;
    }

    m_need_modeset = 1;

    Debug(3, "DRM: HDR metadata: prop set\n");
}