/*
  Simple DirectMedia Layer
  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_internal.h"

#ifdef SDL_VIDEO_RENDER_NGAGE

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#ifndef Int2Fix
#define Int2Fix(i) ((i) << 16)
#endif

#ifndef Fix2Int
#define Fix2Int(i) ((((unsigned int)(i) > 0xFFFF0000) ? 0 : ((i) >> 16)))
#endif

#ifndef Fix2Real
#define Fix2Real(i) ((i) / 65536.0)
#endif

#ifndef Real2Fix
#define Real2Fix(i) ((int)((i) * 65536.0))
#endif

#include "../SDL_sysrender.h"
#include "SDL_render_ngage_c.h"

static void NGAGE_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event);
static bool NGAGE_GetOutputSize(SDL_Renderer *renderer, int *w, int *h);
static bool NGAGE_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode);
static bool NGAGE_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props);
static bool NGAGE_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
static bool NGAGE_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
static bool NGAGE_QueueDrawVertices(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count);
static bool NGAGE_QueueFillRects(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count);
static bool NGAGE_QueueCopy(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect);
static bool NGAGE_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y);
static bool NGAGE_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride, int num_vertices, const void *indices, int num_indices, int size_indices, float scale_x, float scale_y);

static void NGAGE_InvalidateCachedState(SDL_Renderer *renderer);
static bool NGAGE_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize);
static bool NGAGE_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch);

static bool NGAGE_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch);
static void NGAGE_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture);
static bool NGAGE_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture);
static SDL_Surface *NGAGE_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect);
static bool NGAGE_RenderPresent(SDL_Renderer *renderer);
static void NGAGE_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);

static void NGAGE_DestroyRenderer(SDL_Renderer *renderer);

static bool NGAGE_SetVSync(SDL_Renderer *renderer, int vsync);

static bool NGAGE_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
{
    SDL_SetupRendererColorspace(renderer, create_props);

    if (renderer->output_colorspace != SDL_COLORSPACE_RGB_DEFAULT) {
        return SDL_SetError("Unsupported output colorspace");
    }

    NGAGE_RendererData *phdata = SDL_calloc(1, sizeof(NGAGE_RendererData));
    if (!phdata) {
        SDL_OutOfMemory();
        return false;
    }

    renderer->WindowEvent = NGAGE_WindowEvent;
    renderer->GetOutputSize = NGAGE_GetOutputSize;
    renderer->SupportsBlendMode = NGAGE_SupportsBlendMode;
    renderer->CreateTexture = NGAGE_CreateTexture;
    renderer->QueueSetViewport = NGAGE_QueueSetViewport;
    renderer->QueueSetDrawColor = NGAGE_QueueSetDrawColor;
    renderer->QueueDrawPoints = NGAGE_QueueDrawVertices;
    renderer->QueueDrawLines = NGAGE_QueueDrawVertices;
    renderer->QueueFillRects = NGAGE_QueueFillRects;
    renderer->QueueCopy = NGAGE_QueueCopy;
    renderer->QueueCopyEx = NGAGE_QueueCopyEx;
    renderer->QueueGeometry = NGAGE_QueueGeometry;
    renderer->InvalidateCachedState = NGAGE_InvalidateCachedState;
    renderer->RunCommandQueue = NGAGE_RunCommandQueue;
    renderer->UpdateTexture = NGAGE_UpdateTexture;
    renderer->LockTexture = NGAGE_LockTexture;
    renderer->UnlockTexture = NGAGE_UnlockTexture;
    renderer->SetRenderTarget = NGAGE_SetRenderTarget;
    renderer->RenderReadPixels = NGAGE_RenderReadPixels;
    renderer->RenderPresent = NGAGE_RenderPresent;
    renderer->DestroyTexture = NGAGE_DestroyTexture;
    renderer->DestroyRenderer = NGAGE_DestroyRenderer;
    renderer->SetVSync = NGAGE_SetVSync;

    renderer->name = NGAGE_RenderDriver.name;
    renderer->window = window;
    renderer->internal = phdata;
    renderer->npot_texture_wrap_unsupported = true;

    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB4444);
    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB4444);
    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 1024);
    SDL_SetHintWithPriority(SDL_HINT_RENDER_LINE_METHOD, "2", SDL_HINT_OVERRIDE);

    return true;
}

SDL_RenderDriver NGAGE_RenderDriver = {
    NGAGE_CreateRenderer,
    "N-Gage"
};

static void NGAGE_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
{
    return;
}

static bool NGAGE_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
{
    return true;
}

static bool NGAGE_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
{
    switch (blendMode) {
    case SDL_BLENDMODE_NONE:
    case SDL_BLENDMODE_MOD:
        return true;
    default:
        return false;
    }
}

static bool NGAGE_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
{
    NGAGE_TextureData *data = (NGAGE_TextureData *)SDL_calloc(1, sizeof(*data));
    if (!data) {
        return false;
    }

    if (!NGAGE_CreateTextureData(data, texture->w, texture->h, texture->access)) {
        SDL_free(data);
        return false;
    }

    texture->internal = data;

    // ARGB4444 textures are color-keyed: alpha=0 pixels are transparent.
    if (texture->format == SDL_PIXELFORMAT_ARGB4444) {
        data->has_color_key = true;
        data->mask_dirty = true;
    }

    return true;
}

static bool NGAGE_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
{
    if (!cmd->data.viewport.rect.w && !cmd->data.viewport.rect.h) {
        SDL_Rect viewport = { 0, 0, NGAGE_SCREEN_WIDTH, NGAGE_SCREEN_HEIGHT };
        SDL_SetRenderViewport(renderer, &viewport);
    }

    return true;
}

static bool NGAGE_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
{
    return true;
}

static bool NGAGE_QueueDrawVertices(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
{
    NGAGE_Vertex *verts = (NGAGE_Vertex *)SDL_AllocateRenderVertices(renderer, count * sizeof(NGAGE_Vertex), 0, &cmd->data.draw.first);
    if (!verts) {
        return false;
    }

    cmd->data.draw.count = count;

    for (int i = 0; i < count; i++, points++) {
        int fixed_x = Real2Fix(points->x);
        int fixed_y = Real2Fix(points->y);

        verts[i].x = Fix2Int(fixed_x);
        verts[i].y = Fix2Int(fixed_y);

        Uint32 color = NGAGE_ConvertColor(cmd->data.draw.color.r, cmd->data.draw.color.g, cmd->data.draw.color.b, cmd->data.draw.color.a, cmd->data.draw.color_scale);

        verts[i].color.a = (Uint8)(color >> 24);
        verts[i].color.b = (Uint8)(color >> 16);
        verts[i].color.g = (Uint8)(color >> 8);
        verts[i].color.r = (Uint8)color;
    }

    return true;
}

static bool NGAGE_QueueFillRects(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
{
    NGAGE_Vertex *verts = (NGAGE_Vertex *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(NGAGE_Vertex), 0, &cmd->data.draw.first);
    if (!verts) {
        return false;
    }

    cmd->data.draw.count = count;

    for (int i = 0; i < count; i++, rects++) {
        verts[i * 2].x = Real2Fix(rects->x);
        verts[i * 2].y = Real2Fix(rects->y);
        verts[i * 2 + 1].x = Real2Fix(rects->w);
        verts[i * 2 + 1].y = Real2Fix(rects->h);

        verts[i * 2].x = Fix2Int(verts[i * 2].x);
        verts[i * 2].y = Fix2Int(verts[i * 2].y);
        verts[i * 2 + 1].x = Fix2Int(verts[i * 2 + 1].x);
        verts[i * 2 + 1].y = Fix2Int(verts[i * 2 + 1].y);

        Uint32 color = NGAGE_ConvertColor(cmd->data.draw.color.r, cmd->data.draw.color.g, cmd->data.draw.color.b, cmd->data.draw.color.a, cmd->data.draw.color_scale);

        verts[i * 2].color.a = (Uint8)(color >> 24);
        verts[i * 2].color.b = (Uint8)(color >> 16);
        verts[i * 2].color.g = (Uint8)(color >> 8);
        verts[i * 2].color.r = (Uint8)color;
    }

    return true;
}

static bool NGAGE_QueueCopy(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect)
{
    SDL_Rect *verts = (SDL_Rect *)SDL_AllocateRenderVertices(renderer, 2 * sizeof(SDL_Rect), 0, &cmd->data.draw.first);

    if (!verts) {
        return false;
    }

    cmd->data.draw.count = 1;

    verts->x = (int)srcrect->x;
    verts->y = (int)srcrect->y;
    verts->w = (int)srcrect->w;
    verts->h = (int)srcrect->h;

    verts++;

    verts->x = (int)dstrect->x;
    verts->y = (int)dstrect->y;
    verts->w = (int)dstrect->w;
    verts->h = (int)dstrect->h;

    return true;
}

static bool NGAGE_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y)
{
    NGAGE_CopyExData *verts = (NGAGE_CopyExData *)SDL_AllocateRenderVertices(renderer, sizeof(NGAGE_CopyExData), 0, &cmd->data.draw.first);

    if (!verts) {
        return false;
    }

    cmd->data.draw.count = 1;

    verts->srcrect.x = (int)srcquad->x;
    verts->srcrect.y = (int)srcquad->y;
    verts->srcrect.w = (int)srcquad->w;
    verts->srcrect.h = (int)srcquad->h;
    verts->dstrect.x = (int)dstrect->x;
    verts->dstrect.y = (int)dstrect->y;
    verts->dstrect.w = (int)dstrect->w;
    verts->dstrect.h = (int)dstrect->h;

    verts->angle = Real2Fix(angle);
    // Convert center from destination-space to source-space.
    // Center is relative to dstrect, but rotation is applied in source texture space.
    float center_x_src = (center->x / dstrect->w) * srcquad->w;
    float center_y_src = (center->y / dstrect->h) * srcquad->h;
    verts->center.x = Real2Fix(center_x_src);
    verts->center.y = Real2Fix(center_y_src);
    verts->scale_x = Real2Fix(scale_x);
    verts->scale_y = Real2Fix(scale_y);

    verts->flip = flip;

    return true;
}

static bool NGAGE_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride, int num_vertices, const void *indices, int num_indices, int size_indices, float scale_x, float scale_y)
{
    int count = indices ? num_indices : num_vertices;
    NGAGE_Vertex *verts = (NGAGE_Vertex *)SDL_AllocateRenderVertices(renderer, count * sizeof(NGAGE_Vertex), 0, &cmd->data.draw.first);
    if (!verts) {
        return false;
    }
    cmd->data.draw.count = count;

    for (int i = 0; i < count; i++) {
        int src_idx = i;
        if (indices) {
            if (size_indices == 4) {
                src_idx = ((const Uint32 *)indices)[i];
            } else if (size_indices == 2) {
                src_idx = ((const Uint16 *)indices)[i];
            } else {
                src_idx = ((const Uint8 *)indices)[i];
            }
        }
        const float *pos = (const float *)(((const Uint8 *)xy) + src_idx * xy_stride);
        const SDL_FColor *c = (const SDL_FColor *)(((const Uint8 *)color) + src_idx * color_stride);

        verts[i].x = (int)(pos[0] * scale_x);
        verts[i].y = (int)(pos[1] * scale_y);
        verts[i].color.r = (Uint8)(c->r * 255.0f);
        verts[i].color.g = (Uint8)(c->g * 255.0f);
        verts[i].color.b = (Uint8)(c->b * 255.0f);
        verts[i].color.a = (Uint8)(c->a * 255.0f);
    }

    return true;
}

static void NGAGE_InvalidateCachedState(SDL_Renderer *renderer)
{
    return;
}

static bool NGAGE_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
{
    NGAGE_RendererData *phdata = (NGAGE_RendererData *)renderer->internal;
    if (!phdata) {
        return false;
    }
    phdata->viewport = 0;

    while (cmd) {
        switch (cmd->command) {
        case SDL_RENDERCMD_NO_OP:
            break;
        case SDL_RENDERCMD_SETVIEWPORT:
            phdata->viewport = &cmd->data.viewport.rect;
            break;

        case SDL_RENDERCMD_SETCLIPRECT:
        {
            const SDL_Rect *rect = &cmd->data.cliprect.rect;

            if (cmd->data.cliprect.enabled) {
                NGAGE_SetClipRect(rect);
            }

            break;
        }

        case SDL_RENDERCMD_SETDRAWCOLOR:
        {
            break;
        }

        case SDL_RENDERCMD_CLEAR:
        {
            Uint32 color = NGAGE_ConvertColor(cmd->data.color.color.r, cmd->data.color.color.g, cmd->data.color.color.b, cmd->data.color.color.a, cmd->data.color.color_scale);

            NGAGE_Clear(color);
            break;
        }

        case SDL_RENDERCMD_DRAW_POINTS:
        {
            NGAGE_Vertex *verts = (NGAGE_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
            const int count = cmd->data.draw.count;

            // Apply viewport.
            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
                for (int i = 0; i < count; i++) {
                    verts[i].x += phdata->viewport->x;
                    verts[i].y += phdata->viewport->y;
                }
            }

            NGAGE_DrawPoints(verts, count);
            break;
        }
        case SDL_RENDERCMD_DRAW_LINES:
        {
            NGAGE_Vertex *verts = (NGAGE_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
            const int count = cmd->data.draw.count;

            // Apply viewport.
            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
                for (int i = 0; i < count; i++) {
                    verts[i].x += phdata->viewport->x;
                    verts[i].y += phdata->viewport->y;
                }
            }

            NGAGE_DrawLines(verts, count);
            break;
        }

        case SDL_RENDERCMD_FILL_RECTS:
        {
            NGAGE_Vertex *verts = (NGAGE_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
            const int count = cmd->data.draw.count;

            // Apply viewport.
            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
                for (int i = 0; i < count; i++) {
                    verts[i].x += phdata->viewport->x;
                    verts[i].y += phdata->viewport->y;
                }
            }

            NGAGE_FillRects(verts, count);
            break;
        }

        case SDL_RENDERCMD_COPY:
        {
            SDL_Rect *verts = (SDL_Rect *)(((Uint8 *)vertices) + cmd->data.draw.first);
            SDL_Rect *srcrect = verts;
            SDL_Rect *dstrect = verts + 1;
            SDL_Texture *texture = cmd->data.draw.texture;

            // Apply viewport.
            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
                dstrect->x += phdata->viewport->x;
                dstrect->y += phdata->viewport->y;
            }

            NGAGE_Copy(renderer, texture, srcrect, dstrect);
            break;
        }

        case SDL_RENDERCMD_COPY_EX:
        {
            NGAGE_CopyExData *copydata = (NGAGE_CopyExData *)(((Uint8 *)vertices) + cmd->data.draw.first);
            SDL_Texture *texture = cmd->data.draw.texture;

            // Apply viewport.
            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
                copydata->dstrect.x += phdata->viewport->x;
                copydata->dstrect.y += phdata->viewport->y;
            }

            NGAGE_CopyEx(renderer, texture, copydata);
            break;
        }

        case SDL_RENDERCMD_GEOMETRY:
        {
            NGAGE_Vertex *verts = (NGAGE_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
            const int count = cmd->data.draw.count;

            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
                for (int i = 0; i < count; i++) {
                    verts[i].x += phdata->viewport->x;
                    verts[i].y += phdata->viewport->y;
                }
            }

            NGAGE_DrawGeometry(verts, count);
            break;
        }
        }
        cmd = cmd->next;
    }

    return true;
}

static bool NGAGE_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
{
    NGAGE_TextureData *phdata = (NGAGE_TextureData *)texture->internal;

    if (!phdata) {
        return false;
    }

    Uint8 *dst = (Uint8 *)NGAGE_GetBitmapDataAddress(phdata);
    if (!dst) {
        return false;
    }

    const int bytes_per_pixel = 2;
    const int bitmap_pitch = NGAGE_GetBitmapScanLineLength(phdata);

    const Uint8 *src = (const Uint8 *)pixels;
    dst += rect->y * bitmap_pitch + rect->x * bytes_per_pixel;

    const size_t length = (size_t)rect->w * bytes_per_pixel;
    for (int row = 0; row < rect->h; ++row) {
        SDL_memcpy(dst, src, length);
        src += pitch;
        dst += bitmap_pitch;
    }

    phdata->mask_dirty = true;

    return true;
}

static bool NGAGE_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
{
    NGAGE_TextureData *phdata = (NGAGE_TextureData *)texture->internal;

    if (!phdata) {
        return false;
    }

    Uint8 *data = (Uint8 *)NGAGE_GetBitmapDataAddress(phdata);
    if (!data) {
        return false;
    }

    const int bytes_per_pixel = 2;
    const int bitmap_pitch = NGAGE_GetBitmapScanLineLength(phdata);

    *pixels = (void *)(data + rect->y * bitmap_pitch + rect->x * bytes_per_pixel);
    *pitch = bitmap_pitch;
    return true;
}

static void NGAGE_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
{
    NGAGE_TextureData *phdata = (NGAGE_TextureData *)texture->internal;
    if (phdata) {
        phdata->mask_dirty = true;
    }
}

static bool NGAGE_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
{
    NGAGE_RendererData *data = (NGAGE_RendererData *)renderer->internal;

    if (texture) {
        NGAGE_TextureData *texturedata = (NGAGE_TextureData *)texture->internal;
        if (!texturedata || !texturedata->gc) {
            return SDL_SetError("Texture is not a render target");
        }
        data->current_target = texture;
        NGAGE_SetRenderTargetInternal(texturedata);
    } else {
        data->current_target = NULL;
        NGAGE_SetRenderTargetInternal(NULL);
    }

    return true;
}

static SDL_Surface *NGAGE_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
{
    return (SDL_Surface *)0;
}

static bool NGAGE_RenderPresent(SDL_Renderer *renderer)
{
    NGAGE_Flip();

    return true;
}

static void NGAGE_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
{
    NGAGE_TextureData *data = (NGAGE_TextureData *)texture->internal;
    if (data) {
        NGAGE_DestroyTextureData(data);
        SDL_free(data);
        texture->internal = 0;
    }
}

static void NGAGE_DestroyRenderer(SDL_Renderer *renderer)
{
    NGAGE_RendererData *phdata = (NGAGE_RendererData *)renderer->internal;
    if (phdata) {
        SDL_free(phdata);
        renderer->internal = 0;
    }
}

static bool NGAGE_SetVSync(SDL_Renderer *renderer, int vsync)
{
    return true;
}

#endif // SDL_VIDEO_RENDER_NGAGE
