/*
 * Copyright (C) 2025 Amlogic Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <limits.h>

#include "aml_audio_mute.h"

#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif

int aml_audio_mute_bytes_per_sample(mute_sample_format_t fmt) {
    switch (fmt) {
    case MUTE_FMT_S16:   return 2;
    case MUTE_FMT_S32:   return 4;
    case MUTE_FMT_FLOAT: return 4;
    default: return 2;
    }
}

int aml_audio_mute_init(aml_audio_mute_t *h,
                        mute_sample_format_t fmt, int channels, int sample_rate,
                        int default_fade_ms)
{
    if (!h) return -1;
    h->format = fmt;
    h->channels = (channels > 0) ? channels : 2;
    h->sample_rate = (sample_rate > 0) ? sample_rate : 48000;

    /* compute default fade frames (ms -> frames) */
    uint64_t frames = 0;
    if (default_fade_ms > 0) {
        frames = (uint64_t)((int64_t)default_fade_ms * h->sample_rate / 1000);
        if (frames == 0) frames = 1;
    } else {
        frames = 0; /* no fade if zero */
    }
    h->default_fade_frames = frames;

    h->current_gain = 1.0f;
    h->target_gain = 1.0f;
    h->per_frame_delta = 0.0f;
    h->frames_remaining = 0;

    pthread_mutex_init(&h->config_mutex, NULL);
    return 0;
}

int aml_audio_mute_close(aml_audio_mute_t *h) {
    if (!h) return -1;

    pthread_mutex_destroy(&h->config_mutex);

    return 0;
}

int aml_audio_mute_config(aml_audio_mute_t *h, bool mute)
{
    if (!h) return -1;
    float tgt = mute ? 0.0f : 1.0f;

    pthread_mutex_lock(&h->config_mutex);

    /* If already requested same target, return early */
    if (h->target_gain == tgt) {
        pthread_mutex_unlock(&h->config_mutex);
        return 0;
    }

    /* read current gain */
    float cur = h->current_gain;

    uint64_t frames = h->default_fade_frames;
    if (frames == 0) {
        /* immediate switch */
        h->current_gain = tgt;
        h->target_gain = tgt;
        h->per_frame_delta = 0.0f;
        h->frames_remaining = 0;
        pthread_mutex_unlock(&h->config_mutex);
        return 0;
    }

    /* If a fade is in progress and this is a reverse request, use elapsed frames as new duration for more symmetric reversal */
    if (h->frames_remaining > 0 && h->target_gain != tgt) {
        uint64_t elapsed = 0;
        if (h->default_fade_frames > h->frames_remaining)
            elapsed = h->default_fade_frames - h->frames_remaining;
        if (elapsed > 0)
            frames = elapsed; /* Use elapsed frames */
        /* Fall back to default frames when elapsed == 0 */
    }
    /* start fade from current value to target over default frames */
    float delta = (tgt - cur) / (float)frames;

    h->target_gain = tgt;
    h->per_frame_delta = delta;
    h->frames_remaining = frames;

    pthread_mutex_unlock(&h->config_mutex);
    return 0;
}

/* small helpers to apply ramp or constant gain */
static void apply_ramp_float(float *samples, size_t frames, int ch, float start_gain, float delta)
{
    for (size_t f = 0; f < frames; ++f) {
        float g = start_gain + delta * (float)f;
        size_t base = f * (size_t)ch;
        for (int c = 0; c < ch; ++c) {
            samples[base + c] *= g;
        }
    }
}
static void apply_ramp_s32(int32_t *samples, size_t frames, int ch, float start_gain, float delta)
{
    for (size_t f = 0; f < frames; ++f) {
        float g = start_gain + delta * (float)f;
        size_t base = f * (size_t)ch;
        for (int c = 0; c < ch; ++c) {
            samples[base + c] *= g;
        }
    }
}
static void apply_ramp_s16(int16_t *samples, size_t frames, int ch, float start_gain, float delta)
{
    for (size_t f = 0; f < frames; ++f) {
        float g = start_gain + delta * (float)f;
        size_t base = f * (size_t)ch;
        for (int c = 0; c < ch; ++c) {
            samples[base + c] *= g;
        }
    }
}

int aml_audio_mute_process(aml_audio_mute_t *h, void *in_data, size_t size)
{
    if (!h || !in_data || size == 0) return -1;

    int bps = aml_audio_mute_bytes_per_sample(h->format);
    if (bps <= 0 || h->channels <= 0) return -1;

    size_t nframes = size / (bps * (size_t)h->channels);
    if (nframes == 0) return 0;

    /* Lock for full processing (simple design per request) */
    pthread_mutex_lock(&h->config_mutex);

    float cur = h->current_gain;
    uint64_t rem = h->frames_remaining;
    float delta = h->per_frame_delta;
    float tgt = h->target_gain;

    /* Fast paths when no fade pending */
    if (rem == 0) {
        if (cur <= 0.000001f) {
            memset(in_data, 0, size);
            pthread_mutex_unlock(&h->config_mutex);
            return 0;
        }
        if (cur >= 0.999999f) {
            pthread_mutex_unlock(&h->config_mutex);
            return 0; /* bypass */
        }
        /* rem==0 but cur in (0,1): treat as immediate to target */
        h->current_gain = tgt;
        if (tgt <= 0.000001f) memset(in_data, 0, size);
        pthread_mutex_unlock(&h->config_mutex);
        return 0;
    }

    /* There is a fade in progress. Process up to rem frames as ramp, rest with target gain.
       Use at most two passes for performance.
    */
    size_t frames_total = nframes;
    size_t partA = (size_t)MIN((uint64_t)frames_total, rem);
    size_t partB = frames_total - partA;

    /* Apply ramp on first partA frames */
    if (partA > 0) {
        if (h->format == MUTE_FMT_FLOAT) {
            apply_ramp_float((float*)in_data, partA, h->channels, cur, delta);
        } else if (h->format == MUTE_FMT_S32) {
            apply_ramp_s32((int32_t*)in_data, partA, h->channels, cur, delta);
        } else if (h->format == MUTE_FMT_S16) {
            apply_ramp_s16((int16_t*)in_data, partA, h->channels, cur, delta);
        } else {
            pthread_mutex_unlock(&h->config_mutex);
            return -1;
        }

        /* update current_gain and frames_remaining */
        float new_cur = cur + delta * (float)partA;
        h->current_gain = new_cur;
        if (h->frames_remaining > partA)
            h->frames_remaining -= partA;
        else
            h->frames_remaining = 0;
        cur = new_cur;
        rem = h->frames_remaining;
    }

    /* Handle remaining frames (partB) with final target gain */
    if (partB > 0) {
        void *ptr = (uint8_t*)in_data + partA * (size_t)bps * (size_t)h->channels;
        size_t bytesB = partB * (size_t)bps * (size_t)h->channels;
        if (tgt <= 0.000001f) {
            memset(ptr, 0, bytesB);
        } else {
            /* bypass */
        }
        /* If we consumed the remaining fade frames, clear them */
        if (rem <= partB) {
            h->frames_remaining = 0;
            h->per_frame_delta = 0.0f;
            h->current_gain = tgt;
        } else {
            h->frames_remaining -= partB;
            h->current_gain = cur + delta * (float)partB;
        }
    }

    pthread_mutex_unlock(&h->config_mutex);
    return 0;
}