/*
     Copyright 2010-2025 Christian Veit
*/

#include "jit.common.h"
#include "jit.bin.h"


typedef struct _testexternal
{
    t_object				ob;
    long					rows;
    long					cols;
    long					nrOfCells;
    long					frames;
    void* brightnessmatrix;
    long					currentframe;
} t_testexternal;

void* _testexternal_class;

t_jit_err testexternal_init(void);
t_testexternal* testexternal_new(void);
void testexternal_free(t_testexternal* x);
t_jit_err testexternal_fillmatrix(t_testexternal* x);
t_jit_err testexternal_savematrices(t_testexternal* x, long ac, t_atom* av);

void initMatrix(t_testexternal* x);

t_jit_err testexternal_init(void)
{
    void* mop, * output;
    long attrflags;
    t_jit_object* attr;

    _testexternal_class = jit_class_new("testexternal", (method)testexternal_new, (method)testexternal_free,
                                        sizeof(t_testexternal), 0L);


    // add mop
    mop = jit_object_new(_jit_sym_jit_mop, 1,0); // #inputs, #outputs(variable)
    jit_class_addadornment(_testexternal_class, mop);
    // add methods
    jit_class_addmethod(_testexternal_class, (method) testexternal_fillmatrix, "fillmatrix", A_GIMME, 0L);
    jit_class_addmethod(_testexternal_class, (method) testexternal_savematrices, "savematrices", A_GIMME, 0L);
    
    // add attributes
    attrflags = JIT_ATTR_SET_USURP_LOW | JIT_ATTR_GET_DEFER_LOW;
    attr = jit_object_new(_jit_sym_jit_attr_offset, "rows", _jit_sym_long, attrflags,
        (method)0L, (method)0L, calcoffset(t_testexternal, rows));
    jit_class_addattr(_testexternal_class, attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "cols", _jit_sym_long, attrflags,
        (method)0L, (method)0L, calcoffset(t_testexternal, cols));
    jit_class_addattr(_testexternal_class, attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "frames", _jit_sym_long, attrflags,
        (method)0L, (method)0L, calcoffset(t_testexternal, frames));
    jit_class_addattr(_testexternal_class, attr);

    //register class
    jit_class_register(_testexternal_class);

    return JIT_ERR_NONE;
}

t_jit_err testexternal_fillmatrix(t_testexternal* x) {
    
    t_jit_matrix_info brightness_minfo;
    float* brightness_bp, * brightnessp, brightness;
    long i, yCellPos, xCellPos;

    initMatrix(x);
    x->currentframe = 0;

    jit_object_method(x->brightnessmatrix, _jit_sym_getinfo, &brightness_minfo);
    jit_object_method(x->brightnessmatrix, _jit_sym_getdata, &brightness_bp);

    for (x->currentframe = 0; x->currentframe < 3; x->currentframe++) {
        for (i = 0; i < x->nrOfCells; i++) {
            yCellPos = i / x->cols;
            xCellPos = i % x->cols;

            brightness = 25. * i;
            post("i: %ld", i);
            post("x->currentframe: %ld, xPos: %ld, yPos: %ld", x->currentframe, xCellPos, yCellPos);
            post("brightness: %f", brightness);

            brightnessp = brightness_bp  
                + xCellPos * sizeof(float) 
                + yCellPos * sizeof(float) * (&brightness_minfo)->dim[0]
                + x->currentframe * sizeof(float) * (&brightness_minfo)->dim[0] * (&brightness_minfo)->dim[1];
            *brightnessp = brightness;

        }
    }
    post("matrix filled!");
    return JIT_ERR_NONE;
}


void initMatrix(t_testexternal* x) {
    t_jit_matrix_info brightnessinfo;
    if (x->brightnessmatrix == NULL) {
        jit_matrix_info_default(&brightnessinfo);
        brightnessinfo.planecount = 1;
        brightnessinfo.dimcount = 3;
        brightnessinfo.dim[0] = x->cols;
        brightnessinfo.dim[1] = x->rows;
        brightnessinfo.dim[2] = x->frames;
        brightnessinfo.type = _jit_sym_float32; // _jit_sym_float64; //
        x->brightnessmatrix = jit_object_new(_jit_sym_jit_matrix, &brightnessinfo);
        x->nrOfCells = x->rows * x->cols;
    }
}

t_jit_err testexternal_savematrices(t_testexternal* x, long ac, t_atom* av) {
    int t, h, z, e, i;
    char name[MAX_FILENAME_CHARS];
    t_filehandle fh;
    t_ptr_size position;
    long err;
    short pathId, exist, binflag;
    position = 0;
    binflag = 0;
    err = JIT_ERR_NONE;

    pathId = path_getdefault();

    sprintf(name, "brightnessTest.jxf");
    exist = locatefile(name, &pathId, &binflag);
    if (!exist)
    {
        path_deletefile(name, pathId);
        object_error((t_object*)x, "%s: overwriting file", name);
    }

    if (err = path_createsysfile(name, pathId, 'JIT!', &fh)) {
        error("could not create file b");
        goto out;
    }

    if (jit_bin_write_header(fh, position)) {
        error("could not write header");
        sysfile_close(fh);
        goto out;
    }
    if (jit_bin_write_matrix(fh, x->brightnessmatrix)) {
        error("could not write matrix");
        sysfile_close(fh);
        goto out;
    }
    sysfile_getpos(fh, &position);
    sysfile_seteof(fh, position);
    if (jit_bin_write_header(fh, position)) {
        error("jit.matrix: could not write header");
        sysfile_close(fh);
        goto out;
    }
    sysfile_close(fh);
    post("saved brightnessTest.jxf file!");
out:
    return err;
}

t_testexternal* testexternal_new(void)
{
    t_testexternal* x;
    t_jit_matrix_info;

    if (x = (t_testexternal*)jit_object_alloc(_testexternal_class)) {
        x->cols = 1;
        x->rows = 1;
        x->nrOfCells = 1;
        x->currentframe = 0;
    }
    else {
        x = NULL;
    }
    return x;
}

void testexternal_free(t_testexternal* x)
{
    jit_object_free(x->brightnessmatrix);
}