#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include "shmparser/shmparser.h"

static char* timestamp = "2023-1-31 10:05:56.998";
static char* cid = "cameraid";
static char* cname = "cameraname";

static int printlog = 1;
static int savepic = 0;

static struct stimg* pack_image(const int w, const int h,
                                const unsigned char* data, const uint64_t size)
{
    int width = w, height = h;
    uint64_t id = 1223997600787778;

    return make_image_ref(id, data, size, width, height,
        timestamp, strlen(timestamp), cid, strlen(cid), cname, strlen(cname));
}

static void print_image(void* shm, const char* file){
    struct stimg* img = shm2image(shm);

    if (printlog){
        char fmt[128] = {0};
        sprintf(fmt, "imag2 id [%%lu] data size [%%lu] width [%%d] height [%%d] "
            "time [%%%d.%ds] cid [%%%d.%ds] cname [%%%d.%ds]",
            img->timestamp_size, img->timestamp_size,
            img->camera_id_size, img->camera_id_size,
            img->camera_name_size, img->camera_name_size);

        printf(fmt, img->id, img->data_size, img->width, img->height, img->timestamp, img->camera_id, img->camera_name);
        printf("\n");
    }

    if (savepic){
        FILE* fp = fopen(file, "wb");
        long pos = 0;
        while (pos != img->data_size) {
            pos += fwrite(img->data+pos, 1, img->data_size-pos, fp);
        }
        fclose(fp);
    }


    free_stimg(img);
}

static void readfile(const char* file, unsigned char** data, size_t* size){
    FILE* fp = fopen(file, "rb");
    if (!fp) {
        printf("file %s error %s\n", file, strerror(errno));
        return;
    }

    fseek(fp, 0, SEEK_END);
    *size = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    unsigned char* d = (unsigned char*)malloc(*size);
    long s = *size;
    long pos = 0;
    while (pos != *size) {
        pos += fread(d+pos, 1, s-pos, fp);
    }

    *data = d;

    fclose(fp);
}

static void test_image(void* shm, const int order){

    const char* pics[] = {
        "../opic/720x576.jpg",
        "../opic/720x576.bgr",
        "../opic/1920x1080.jpg",
        "../opic/1920x1080.bgr",
    };

    unsigned char* d = NULL;
    size_t s = 0;

    if (order == 0)
        for(int i = 0; i < sizeof(pics)/sizeof(pics[0]); i++){
            readfile(pics[i], &d, &s);
            int w = 0, h = 0;
            if (i < 2){
                w = 720, h = 576;
            }else{
                w = 1920, h = 1080;
            }
            struct stimg* img = pack_image(w, h, d, s);
            image2shm(shm, img);
            free_stimg(img);
            free(d);
            char file[128] = {0};
            sprintf(file, "../npic/%dx%d.%d", w, h, i);
            print_image(shm, file);
        }
    else
        for(int i = sizeof(pics)/sizeof(pics[0]) - 1; i >= 0; i--){
            readfile(pics[i], &d, &s);
            int w = 0, h = 0;
            if (i < 2){
                w = 720, h = 576;
            }else{
                w = 1920, h = 1080;
            }
            struct stimg* img = pack_image(w, h, d, s);
            image2shm(shm, img);
            free_stimg(img);
            free(d);
            char file[128] = {0};
            sprintf(file, "../npic/%dx%d.%d", w, h, i);
            print_image(shm, file);
        }
}

static void test_rule(void* shm);

static int test_once(void* shm, const int count){

    struct timeval s, e;
    gettimeofday(&s, NULL);

    for(int i = 0; i < count; i++)
        test_rule(shm);

    for(int i = 0; i < count; i++){
        test_image(shm, 0);
        // test_image(shm, 1);
    }
    for(int i = 0; i < count; i++){
        // test_image(shm, 0);
        test_image(shm, 1);
    }
    for(int i = 0; i < count; i++){
        test_image(shm, 0);
        test_image(shm, 1);
    }
    for(int i = 0; i < count; i++){
        test_image(shm, 1);
        test_image(shm, 0);
    }

    for(int i = 0; i < count; i++)
        test_rule(shm);

    gettimeofday(&e, NULL);

    return (e.tv_sec- s.tv_sec)*1000 + (e.tv_usec - s.tv_usec)/1000;
}

int main(int argc, char const *argv[])
{
    char* shm = (char*)malloc(10*1024*1024);

    int cntPerTest = 1000;
    int cntRun = 1;
    int avg = 0;
    for(int i = 1; i <= cntRun; i++){
        int tm = test_once(shm, cntPerTest);
        if (avg == 0) avg = tm;
        else avg = (double)avg / (double) i * (double)(i-1) + (double)tm / (double)i;
    }

    printf("run %d time test, each %d use %d ms\n", cntPerTest*cntRun, cntPerTest, avg);

    return 0;
}

static Target* pack_target(const int size){
    Target* tgts = (Target*)calloc(size, sizeof(Target));
    for(int i = 0; i < size; i++){
        tgts[i].id = i + 1002;
        tgts[i].confidence = 99-i;
        TRect rc = {0,0,1920,1080};
        memcpy(&tgts[i].rect, &rc, sizeof(TRect));
        memcpy(tgts[i].type, "pack_target", 11);
        tgts[i].feature_size = 123;
        tgts[i].feature = (char*)calloc(tgts[i].feature_size, 1);
        memcpy(tgts[i].feature, "feature and feature_size", 24);
        tgts[i].attribute_size = 235;
        tgts[i].attribute = (char*)calloc(tgts[i].attribute_size, 1);
        memcpy(tgts[i].attribute, "attribute and attribute_size", 28);
    }
    return tgts;
}
static void print_targets(struct sttgt* tgts, const int count){
    for(int i = 0; i < count; i++){
        struct sttgt* tgt = &tgts[i];
        printf("\t\t<target> [%d] id [%lu] confidence [%d] rect [%dx%dx%dx%d] type [%s] \
            feature_size [%d] feature [%s] attribute_size [%d] attribute [%s]\n",
            i, tgt->id, tgt->confidence,
            tgt->rect.left, tgt->rect.top, tgt->rect.right, tgt->rect.bottom,
            tgt->type,
            tgt->feature_size, tgt->feature, tgt->attribute_size, tgt->attribute);
    }
}

const char* sdktype[] = { "face", "yolo", "bike", "fire", "car" };
static void pack_result(void* shm, const int s, const int e){

    int sdkcnt = e - s;

    TResult* resarray = (TResult*)calloc(sdkcnt, sizeof(TResult));
    for(size_t i = 0; i < sdkcnt; i++){
        resarray[i].count = 2+i;
        resarray[i].targets = pack_target(resarray[i].count);
    }

    for(size_t i = 0; i < sdkcnt; i++){
        add_result2rule_in_shm(shm, &resarray[i],
            sdktype[s+i], strlen(sdktype[i+s]), timestamp, strlen(timestamp));
    }

    for(size_t i = 0; i < sdkcnt; i++){
        for(int j = 0; j < resarray[i].count; j++){
            free(resarray[i].targets[j].feature);
            free(resarray[i].targets[j].attribute);
        }
        free(resarray[i].targets);
    }
    free(resarray);
}

static char* handletrack = "camera1";
static void pack_rule(void* shm){

    rule2shm(shm, handletrack, strlen(handletrack));
    pack_result(shm, 0, 3);
}
static void print_rule(void* shm){
    struct strule* rule = shm2rule(shm);

    if (printlog)
        printf("<rule> handletrack [%s] datatype [%s]\n", rule->handletrack, rule->datatype);

    for(int i = 0; i < rule->sdk_count; i++){

        struct stsdk* sdk = &rule->sdk[i];
        if (printlog){
            printf("\t<sdk> [%d] type [%s] tgts [%d] id [%s] name [%s] timestamp [%s]\n",
                i, sdk->sdktype, sdk->tgt_count, sdk->sdkid, sdk->sdkname, sdk->timestamp);

            print_targets(sdk->tgt, sdk->tgt_count);
        }

    }
    free_strule(rule);
}

static void test_rule(void* shm){
    pack_rule(shm);
    pack_result(shm, 2, 5);

    pack_result(shm, 0, 5);

    // 测试时发现如果取 6 造成 rule 中的 handletrack 字符串的长度溢出
    // 取 5 时大约有 35 个 sdk 运行，目前一张图片不会运行 35 个 sdk
    // 暂时保留 handletrack 的 256 个字符限制
    // for(int i = 0; i < 6; i++){
    for(int i = 0; i < 5; i++){
        pack_result(shm, 0, 5);
    }

    print_rule(shm);
}