// SPDX-License-Identifier: GPL-2.0-only
// Copyright (c) 2025 Šerif Rami <ramiserifpersia@gmail.com>

#include "us144mkii.h"

/*
 * tascam_playback_open() - Opens the PCM playback substream.
 * @substream: The ALSA PCM substream to open.
 *
 * This function sets the hardware parameters for the playback substream
 * and stores a reference to the substream in the driver's private data.
 *
 * Return: 0 on success.
 */
static int tascam_playback_open(struct snd_pcm_substream *substream)
{
        struct tascam_card *tascam = snd_pcm_substream_chip(substream);

        substream->runtime->hw = tascam_pcm_hw;
        tascam->playback_substream = substream;
        atomic_set(&tascam->playback_active, 0);

        return 0;
}

/*
 * tascam_playback_close() - Closes the PCM playback substream.
 * @substream: The ALSA PCM substream to close.
 *
 * This function clears the reference to the playback substream in the
 * driver's private data.
 *
 * Return: 0 on success.
 */
static int tascam_playback_close(struct snd_pcm_substream *substream)
{
        struct tascam_card *tascam = snd_pcm_substream_chip(substream);

        tascam->playback_substream = NULL;

        return 0;
}

/*
 * tascam_playback_prepare() - Prepares the PCM playback substream for use.
 * @substream: The ALSA PCM substream to prepare.
 *
 * This function initializes playback-related counters and flags, and configures
 * the playback URBs with appropriate packet sizes based on the nominal frame
 * rate.
 *
 * Return: 0 on success.
 */
static int tascam_playback_prepare(struct snd_pcm_substream *substream)
{
        struct tascam_card *tascam = snd_pcm_substream_chip(substream);
        struct snd_pcm_runtime *runtime = substream->runtime;
        int i, u;
        size_t nominal_frames_per_packet, nominal_bytes_per_packet;
        size_t total_bytes_in_urb;

        tascam->driver_playback_pos = 0;
        tascam->playback_frames_consumed = 0;
        tascam->last_period_pos = 0;
        tascam->feedback_pattern_in_idx = 0;
        tascam->feedback_pattern_out_idx = 0;
        tascam->feedback_synced = false;
        tascam->feedback_consecutive_errors = 0;
        tascam->feedback_urb_skip_count = NUM_FEEDBACK_URBS;

        nominal_frames_per_packet = runtime->rate / 8000;
        for (i = 0; i < FEEDBACK_ACCUMULATOR_SIZE; i++)
                tascam->feedback_accumulator_pattern[i] =
                        nominal_frames_per_packet;

        for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
                struct urb *f_urb = tascam->feedback_urbs[i];
                int j;

                f_urb->number_of_packets = FEEDBACK_URB_PACKETS;
                f_urb->transfer_buffer_length =
                        FEEDBACK_URB_PACKETS * FEEDBACK_PACKET_SIZE;
                for (j = 0; j < FEEDBACK_URB_PACKETS; j++) {
                        f_urb->iso_frame_desc[j].offset =
                                j * FEEDBACK_PACKET_SIZE;
                        f_urb->iso_frame_desc[j].length = FEEDBACK_PACKET_SIZE;
                }
        }

        nominal_bytes_per_packet = nominal_frames_per_packet * BYTES_PER_FRAME;
        total_bytes_in_urb = nominal_bytes_per_packet * PLAYBACK_URB_PACKETS;

        for (u = 0; u < NUM_PLAYBACK_URBS; u++) {
                struct urb *urb = tascam->playback_urbs[u];

                memset(urb->transfer_buffer, 0,
                       tascam->playback_urb_alloc_size);
                urb->transfer_buffer_length = total_bytes_in_urb;
                urb->number_of_packets = PLAYBACK_URB_PACKETS;
                for (i = 0; i < PLAYBACK_URB_PACKETS; i++) {
                        urb->iso_frame_desc[i].offset =
                                i * nominal_bytes_per_packet;
                        urb->iso_frame_desc[i].length =
                                nominal_bytes_per_packet;
                }
        }

        return 0;
}

/*
 * tascam_playback_pointer() - Returns the current playback pointer position.
 * @substream: The ALSA PCM substream.
 *
 * This function returns the current position of the playback pointer within
 * the ALSA ring buffer, in frames.
 *
 * Return: The current playback pointer position in frames.
 */
static snd_pcm_uframes_t
tascam_playback_pointer(struct snd_pcm_substream *substream)
{
        struct tascam_card *tascam = snd_pcm_substream_chip(substream);
        struct snd_pcm_runtime *runtime = substream->runtime;
        u64 pos;

        if (!atomic_read(&tascam->playback_active))
                return 0;

        scoped_guard(spinlock_irqsave, &tascam->lock) {
                pos = tascam->playback_frames_consumed;
        }

        if (runtime->buffer_size == 0)
                return 0;

        return do_div(pos, runtime->buffer_size);
}

/*
 * tascam_playback_ops - ALSA PCM operations for playback.
 *
 * This structure defines the callback functions for playback stream operations,
 * including open, close, ioctl, hardware parameters, hardware free, prepare,
 * trigger, and pointer.
 */
const struct snd_pcm_ops tascam_playback_ops = {
        .open = tascam_playback_open,
        .close = tascam_playback_close,
        .ioctl = snd_pcm_lib_ioctl,
        .hw_params = tascam_pcm_hw_params,
        .hw_free = tascam_pcm_hw_free,
        .prepare = tascam_playback_prepare,
        .trigger = tascam_pcm_trigger,
        .pointer = tascam_playback_pointer,
};

void playback_urb_complete(struct urb *urb)
{
        struct tascam_card *tascam = urb->context;
        struct snd_pcm_substream *substream;
        struct snd_pcm_runtime *runtime;
        size_t total_bytes_for_urb = 0;
        snd_pcm_uframes_t offset_frames;
        snd_pcm_uframes_t frames_to_copy;
        int ret, i;

        if (urb->status) {
                if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
                    urb->status != -ESHUTDOWN && urb->status != -ENODEV)
                        dev_err_ratelimited(tascam->card->dev,
                                            "Playback URB failed: %d\n",
                                            urb->status);
                goto out;
        }
        if (!tascam || !atomic_read(&tascam->playback_active))
                goto out;

        substream = tascam->playback_substream;
        if (!substream || !substream->runtime)
                goto out;
        runtime = substream->runtime;

        scoped_guard(spinlock_irqsave, &tascam->lock) {
                for (i = 0; i < urb->number_of_packets; i++) {
                        unsigned int frames_for_packet;
                        size_t bytes_for_packet;

                        if (tascam->feedback_synced) {
                                frames_for_packet =
                                        tascam->feedback_accumulator_pattern
                                                [tascam->feedback_pattern_out_idx];
                                tascam->feedback_pattern_out_idx =
                                        (tascam->feedback_pattern_out_idx + 1) %
                                        FEEDBACK_ACCUMULATOR_SIZE;
                        } else {
                                frames_for_packet = runtime->rate / 8000;
                        }
                        bytes_for_packet = frames_for_packet * BYTES_PER_FRAME;

                        urb->iso_frame_desc[i].offset = total_bytes_for_urb;
                        urb->iso_frame_desc[i].length = bytes_for_packet;
                        total_bytes_for_urb += bytes_for_packet;
                }
                urb->transfer_buffer_length = total_bytes_for_urb;

                offset_frames = tascam->driver_playback_pos;
                frames_to_copy = bytes_to_frames(runtime, total_bytes_for_urb);
                tascam->driver_playback_pos =
                        (offset_frames + frames_to_copy) % runtime->buffer_size;
        }

        if (total_bytes_for_urb > 0) {
                u8 *dst_buf = urb->transfer_buffer;

                /* Handle ring buffer wrap-around */
                if (offset_frames + frames_to_copy > runtime->buffer_size) {
                        size_t first_chunk_bytes = frames_to_bytes(
                                runtime, runtime->buffer_size - offset_frames);
                        size_t second_chunk_bytes =
                                total_bytes_for_urb - first_chunk_bytes;

                        memcpy(dst_buf,
                               runtime->dma_area +
                                       frames_to_bytes(runtime, offset_frames),
                               first_chunk_bytes);
                        memcpy(dst_buf + first_chunk_bytes, runtime->dma_area,
                               second_chunk_bytes);
                } else {
                        memcpy(dst_buf,
                               runtime->dma_area +
                                       frames_to_bytes(runtime, offset_frames),
                               total_bytes_for_urb);
                }

                process_playback_routing_us144mkii(tascam, dst_buf, dst_buf,
                                                   frames_to_copy);
        }

        urb->dev = tascam->dev;
        usb_get_urb(urb);
        usb_anchor_urb(urb, &tascam->playback_anchor);
        ret = usb_submit_urb(urb, GFP_ATOMIC);
        if (ret < 0) {
                dev_err_ratelimited(tascam->card->dev,
                                    "Failed to resubmit playback URB: %d\n",
                                    ret);
                usb_unanchor_urb(urb);
                usb_put_urb(urb);
                atomic_dec(
                        &tascam->active_urbs); /* Decrement on failed resubmission */
        }
out:
        usb_put_urb(urb);
}

void feedback_urb_complete(struct urb *urb)
{
        struct tascam_card *tascam = urb->context;
        struct snd_pcm_substream *playback_ss, *capture_ss;
        struct snd_pcm_runtime *playback_rt, *capture_rt;
        u64 total_frames_in_urb = 0;
        int ret, p;
        unsigned int old_in_idx, new_in_idx;
        bool playback_period_elapsed = false;
        bool capture_period_elapsed = false;

        if (urb->status) {
                if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
                    urb->status != -ESHUTDOWN && urb->status != -ENODEV) {
                        dev_err_ratelimited(tascam->card->dev,
                                            "Feedback URB failed: %d\n",
                                            urb->status);
                        atomic_dec(
                                &tascam->active_urbs); /* Decrement on failed resubmission */
                }
                goto out;
        }
        if (!tascam || !atomic_read(&tascam->playback_active))
                goto out;

        playback_ss = tascam->playback_substream;
        if (!playback_ss || !playback_ss->runtime)
                goto out;
        playback_rt = playback_ss->runtime;

        capture_ss = tascam->capture_substream;
        capture_rt = capture_ss ? capture_ss->runtime : NULL;

        scoped_guard(spinlock_irqsave, &tascam->lock) {
                if (tascam->feedback_urb_skip_count > 0) {
                        tascam->feedback_urb_skip_count--;
                        break;
                }

                old_in_idx = tascam->feedback_pattern_in_idx;

                for (p = 0; p < urb->number_of_packets; p++) {
                        u8 feedback_value = 0;
                        const unsigned int *pattern;
                        bool packet_ok =
                                (urb->iso_frame_desc[p].status == 0 &&
                                 urb->iso_frame_desc[p].actual_length >= 1);

                        if (packet_ok)
                                feedback_value =
                                        *((u8 *)urb->transfer_buffer +
                                          urb->iso_frame_desc[p].offset);

                        if (packet_ok) {
                                int delta = feedback_value -
                                                    tascam->fpo.base_feedback_value +
                                                    tascam->fpo.feedback_offset;
                                int pattern_idx;

                                if (delta < 0) {
                                        pattern_idx =
                                                0; // Clamp to the lowest pattern
                                } else if (delta >= 5) {
                                        pattern_idx =
                                                4; // Clamp to the highest pattern
                                } else {
                                        pattern_idx = delta;
                                }

                                pattern =
                                        tascam->fpo
                                                .full_frame_patterns[pattern_idx];
                                tascam->feedback_consecutive_errors = 0;
                                int i;

                                for (i = 0; i < 8; i++) {
                                        unsigned int in_idx =
                                                (tascam->feedback_pattern_in_idx +
                                                 i) %
                                                FEEDBACK_ACCUMULATOR_SIZE;

                                        tascam->feedback_accumulator_pattern
                                                [in_idx] = pattern[i];
                                        total_frames_in_urb += pattern[i];
                                }
                        } else {
                                unsigned int nominal_frames =
                                        playback_rt->rate / 8000;
                                int i;

                                if (tascam->feedback_synced) {
                                        tascam->feedback_consecutive_errors++;
                                        if (tascam->feedback_consecutive_errors >
                                            FEEDBACK_SYNC_LOSS_THRESHOLD) {
                                                dev_err(tascam->card->dev,
                                                        "Fatal: Feedback sync lost. Stopping stream.\n");
                                                schedule_work(
                                                                &tascam->stop_pcm_work);
                                                tascam->feedback_synced = false;
                                                break;
                                        }
                                }
                                for (i = 0; i < 8; i++) {
                                        unsigned int in_idx =
                                                (tascam->feedback_pattern_in_idx +
                                                 i) %
                                                FEEDBACK_ACCUMULATOR_SIZE;

                                        tascam->feedback_accumulator_pattern
                                                [in_idx] = nominal_frames;
                                        total_frames_in_urb += nominal_frames;
                                }
                        }
                        tascam->feedback_pattern_in_idx =
                                (tascam->feedback_pattern_in_idx + 8) %
                                FEEDBACK_ACCUMULATOR_SIZE;
                }

                new_in_idx = tascam->feedback_pattern_in_idx;

                if (!tascam->feedback_synced) {
                        unsigned int out_idx = tascam->feedback_pattern_out_idx;
                        bool is_ahead = (new_in_idx - out_idx) %
                                                FEEDBACK_ACCUMULATOR_SIZE <
                                        (FEEDBACK_ACCUMULATOR_SIZE / 2);
                        bool was_behind = (old_in_idx - out_idx) %
                                                FEEDBACK_ACCUMULATOR_SIZE >=
                                        (FEEDBACK_ACCUMULATOR_SIZE / 2);

                        if (is_ahead && was_behind) {
                                dev_dbg(tascam->card->dev,
                                        "Sync Acquired! (in: %u, out: %u)\n",
                                        new_in_idx, out_idx);
                                tascam->feedback_synced = true;
                                tascam->feedback_consecutive_errors = 0;
                        }
                }

                if (total_frames_in_urb > 0) {
                        tascam->playback_frames_consumed += total_frames_in_urb;
                        if (atomic_read(&tascam->capture_active))
                                tascam->capture_frames_processed +=
                                        total_frames_in_urb;
                }

                if (playback_rt->period_size > 0) {
                        u64 current_period =
                                div_u64(tascam->playback_frames_consumed,
                                                playback_rt->period_size);

                        if (current_period > tascam->last_period_pos) {
                                tascam->last_period_pos = current_period;
                                playback_period_elapsed = true;
                        }
                }

                if (atomic_read(&tascam->capture_active) && capture_rt &&
                    capture_rt->period_size > 0) {
                        u64 current_capture_period =
                                div_u64(tascam->capture_frames_processed,
                                                capture_rt->period_size);

                        if (current_capture_period >
                            tascam->last_capture_period_pos) {
                                tascam->last_capture_period_pos =
                                        current_capture_period;
                                capture_period_elapsed = true;
                        }
                }
        }
        if (playback_period_elapsed)
                snd_pcm_period_elapsed(playback_ss);
        if (capture_period_elapsed)
                snd_pcm_period_elapsed(capture_ss);

        urb->dev = tascam->dev;
        usb_get_urb(urb);
        usb_anchor_urb(urb, &tascam->feedback_anchor);
        ret = usb_submit_urb(urb, GFP_ATOMIC);
        if (ret < 0) {
                dev_err_ratelimited(tascam->card->dev,
                                    "Failed to resubmit feedback URB: %d\n",
                                    ret);
                usb_unanchor_urb(urb);
                usb_put_urb(urb);
        }
out:
        usb_put_urb(urb);
}

void tascam_stop_pcm_work_handler(struct work_struct *work)
{
        struct tascam_card *tascam =
                container_of(work, struct tascam_card, stop_pcm_work);

        if (tascam->playback_substream)
                snd_pcm_stop(tascam->playback_substream, SNDRV_PCM_STATE_XRUN);
        if (tascam->capture_substream)
                snd_pcm_stop(tascam->capture_substream, SNDRV_PCM_STATE_XRUN);
}