#include "PaintedGrid.h"

#include "Interpolation.h"
#include "Memory.h"
#include "PaintedGridBrush.h"
#include "PaintedGridData.h"
#include <cassert>
#include <cmath>

PaintedGrid::PaintedGrid(DefinitionNode *parent) : DefinitionNode(parent, "grid", "grid") {
    merged_data = new PaintedGridData;
    brush_data = new PaintedGridData;
}

PaintedGrid::~PaintedGrid() {
    delete merged_data;
    delete brush_data;
}

void PaintedGrid::copy(DefinitionNode *_destination) const {
    PaintedGrid *destination = (PaintedGrid *)_destination;

    merged_data->copy(destination->merged_data);
    destination->brush_data->clear();
}

void PaintedGrid::save(PackStream *stream) const {
    merged_data->save(stream);
}

void PaintedGrid::load(PackStream *stream) {
    merged_data->load(stream);
    brush_data->clear();
}

bool PaintedGrid::getInterpolatedValue(double x, double y, double *result) const {
    int ix, iy;
    int xlow;
    int ylow;

    xlow = floor_to_int(x);
    ylow = floor_to_int(y);

    int hit = 0;
    for (ix = xlow - 1; ix <= xlow + 2 && !hit; ix++) {
        for (iy = ylow - 1; iy <= ylow + 2 && !hit; iy++) {
            if (getDataPointer(brush_data, x, y, NULL, false) || getDataPointer(merged_data, x, y, NULL, false)) {
                hit = 1;
            }
        }
    }

    if (hit && result) {
        double stencil[16];
        double value;
        for (ix = xlow - 1; ix <= xlow + 2; ix++) {
            for (iy = ylow - 1; iy <= ylow + 2; iy++) {
                if (!getGridValue(ix, iy, &value)) {
                    value = getInitialValue(ix, iy);
                }
                stencil[(iy - (ylow - 1)) * 4 + ix - (xlow - 1)] = value;
            }
        }

        *result = Interpolation::bicubic(stencil, x - to_double(xlow), y - to_double(ylow));
    }

    return hit;
}

bool PaintedGrid::getGridValue(int x, int y, double *result) const {
    double *dpointer;
    dpointer = getDataPointer(brush_data, x, y, NULL, false);
    if (dpointer) {
        *result = *dpointer;
        return true;
    } else {
        dpointer = getDataPointer(merged_data, x, y, NULL, false);
        if (dpointer) {
            *result = *dpointer;
            return true;
        } else {
            return false;
        }
    }
}

double PaintedGrid::getFinalValue(double x, double y) const {
    double result;

    if (getInterpolatedValue(x, y, &result)) {
        return result;
    } else {
        return getInitialValue(x, y);
    }
}

bool PaintedGrid::hasPainting() const {
    return merged_data->hasData() || brush_data->hasData();
}

bool PaintedGrid::isPainted(int x, int y) const {
    return getDataPointer(brush_data, x, y, NULL, false) || getDataPointer(merged_data, x, y, NULL, false);
}

unsigned long PaintedGrid::getMemoryStats() const {
    return merged_data->memsize + brush_data->memsize;
}

void PaintedGrid::clearPainting() {
    merged_data->clear();
    brush_data->clear();
}

void PaintedGrid::applyBrush(const PaintedGridBrush &brush, double x, double y, double force, bool commit) {
    int xstart, xend, ystart, yend;

    brush.getArea(x, y, &xstart, &ystart, &xend, &yend);

    int ix, iy;
    double dx, dy, influence;

    for (ix = xstart; ix <= xend; ix++) {
        dx = to_double(ix);
        for (iy = ystart; iy <= yend; iy++) {
            dy = to_double(iy);

            influence = brush.getInfluence(x - dx, y - dy);

            if (influence > 0.0) {
                double *dpointer = getDataPointer(brush_data, ix, iy, merged_data, true);
                *dpointer = brush.getValue(this, dx, dy, *dpointer, influence, force);
            }
        }
    }

    if (commit) {
        endBrushStroke();
    }
}

void PaintedGrid::endBrushStroke() {
    int i, j, k;
    PaintedGridData *data = brush_data;

    for (i = 0; i < data->rows_count; i++) {
        for (j = 0; j < data->rows[i].pixel_groups_count; j++) {
            for (k = 0; k < data->rows[i].pixel_groups[j].xend - data->rows[i].pixel_groups[j].xstart + 1; k++) {
                double *dpointer =
                    getDataPointer(merged_data, data->rows[i].pixel_groups[j].xstart + k, data->rows[i].y, NULL, true);
                *dpointer = data->rows[i].pixel_groups[j].height[k];
            }
        }
    }

    brush_data->clear();
}

double PaintedGrid::getInitialValue(double, double) const {
    return 0.0;
}

double *PaintedGrid::getDataPointer(PaintedGridData *data, int x, int y, PaintedGridData *fallback, bool grow) const {
    int i;

    /* Find row */
    /* TODO Dichotomic search */
    PaintedGridData::HeightMapRow *row;
    i = 0;
    while (i < data->rows_count && data->rows[i].y < y) {
        i++;
    }
    if (i < data->rows_count && data->rows[i].y == y) {
        row = data->rows + i;
    } else if (grow) {
        row = (PaintedGridData::HeightMapRow *)Memory::naiveArrayInsert(
            (void **)&data->rows, sizeof(PaintedGridData::HeightMapRow), data->rows_count, i);

        row->y = y;
        row->pixel_groups_count = 0;
        row->pixel_groups = (PaintedGridData::HeightMapPixelGroup *)malloc(1);

        data->rows_count++;
        data->memsize += sizeof(PaintedGridData::HeightMapRow);
    } else {
        return NULL;
    }

#ifndef NDEBUG
    /* Check rows */
    for (i = 1; i < data->rows_count; i++) {
        assert(data->rows[i].y > data->rows[i - 1].y);
    }
#endif

    /* Find pixel group */
    PaintedGridData::HeightMapPixelGroup *pixel_group = NULL;
    for (i = 0; i < row->pixel_groups_count; i++) {
        if (x < row->pixel_groups[i].xstart - 1) {
            break;
        } else if (x <= row->pixel_groups[i].xend + 1) {
            if (x == row->pixel_groups[i].xend + 1 && i < row->pixel_groups_count - 1 &&
                x == row->pixel_groups[i + 1].xstart) {
                /* Choose next group if it already includes the pixel */
                i++;
            }
            pixel_group = row->pixel_groups + i;
            break;
        }
    }

    /* Alter pixel group */
    double *pixel;
    int added = 1;
    if (!pixel_group) {
        if (!grow) {
            return NULL;
        }

        /* Create the pixel group with one pixel */
        pixel_group = (PaintedGridData::HeightMapPixelGroup *)Memory::naiveArrayInsert(
            (void **)&row->pixel_groups, sizeof(PaintedGridData::HeightMapPixelGroup), row->pixel_groups_count, i);

        pixel_group->xstart = x;
        pixel_group->xend = x;
        pixel_group->height = (double *)malloc(sizeof(double));

        pixel = pixel_group->height;

        row->pixel_groups_count++;
        data->memsize += sizeof(PaintedGridData::HeightMapPixelGroup) + sizeof(double);
    } else if (x == pixel_group->xstart - 1) {
        if (!grow) {
            return NULL;
        }

        /* Extend the rowgroup at start */
        pixel_group->xstart--;
        pixel = (double *)Memory::naiveArrayInsert((void **)&pixel_group->height, sizeof(double),
                                                   pixel_group->xend - pixel_group->xstart, 0);
        data->memsize += sizeof(double);
    } else if (x == pixel_group->xend + 1) {
        if (!grow) {
            return NULL;
        }

        /* Extend the rowgroup at end */
        pixel_group->xend++;
        pixel = (double *)Memory::naiveArrayInsert((void **)&pixel_group->height, sizeof(double),
                                                   pixel_group->xend - pixel_group->xstart,
                                                   pixel_group->xend - pixel_group->xstart);
        data->memsize += sizeof(double);
    } else {
        assert(x >= pixel_group->xstart);
        assert(x <= pixel_group->xend);
        pixel = pixel_group->height + x - pixel_group->xstart;
        added = 0;
    }

#ifndef NDEBUG
    /* Check pixel groups */
    for (i = 0; i < row->pixel_groups_count; i++) {
        if (i > 0) {
            assert(row->pixel_groups[i].xstart > row->pixel_groups[i - 1].xend);
        }
        if (i < row->pixel_groups_count - 1) {
            assert(row->pixel_groups[i].xend < row->pixel_groups[i + 1].xstart);
        }
        assert(row->pixel_groups[i].xend >= row->pixel_groups[i].xstart);
    }
#endif

    /* Reset pixel if it had been added */
    if (added) {
        if (fallback) {
            double *dpointer = getDataPointer(fallback, x, y, NULL, false);
            if (dpointer) {
                *pixel = *dpointer;
            } else {
                *pixel = getInitialValue(x, y);
            }
        } else {
            *pixel = getInitialValue(x, y);
        }
    }

    return pixel;
}