#include "MelodyStrategy.h"
#include <Arduino.h>

#ifndef CALL_AND_RESPONSE_STRATEGY_H
#define CALL_AND_RESPONSE_STRATEGY_H

class CallAndResponseStrategy : public MelodyStrategy {
public:
    void generate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int seed, int intensity) override {
        randomSeed(seed);
        if (numScaleNotes == 0) return;

        int halfSteps = numSteps / 2;
        if (halfSteps < 1) halfSteps = 1;

        // Generate Call (First Half)
        for (int i = 0; i < halfSteps; i++) {
            // Simple random generation for the call, weighted by intensity
            if (random(100) < (intensity * 8 + 20)) {
                int octave = 3 + random(3);
                sequence[track][i].note = 12 * octave + scaleNotes[random(numScaleNotes)];
                sequence[track][i].accent = (random(100) < 30);
                sequence[track][i].tie = (random(100) < 10);
            } else {
                sequence[track][i].note = -1;
                sequence[track][i].accent = false;
                sequence[track][i].tie = false;
            }
        }

        // Generate Response (Second Half)
        for (int i = halfSteps; i < numSteps; i++) {
            int srcIndex = i - halfSteps;
            Step srcStep = sequence[track][srcIndex];
            
            // Default: Copy
            sequence[track][i] = srcStep;

            // Variation based on intensity
            if (srcStep.note != -1) {
                int r = random(100);
                if (r < intensity * 5) {
                    // Transpose / Shift
                    int shift = random(-2, 3); 
                    int octave = srcStep.note / 12;
                    int noteVal = srcStep.note % 12;
                    
                    // Find index in scale
                    int idx = 0;
                    for(int k=0; k<numScaleNotes; k++) if(scaleNotes[k] == noteVal) idx = k;
                    
                    idx = (idx + shift + numScaleNotes) % numScaleNotes;
                    sequence[track][i].note = 12 * octave + scaleNotes[idx];
                } else if (r < intensity * 8) {
                    // New random note (Variation)
                     int octave = 3 + random(3);
                     sequence[track][i].note = 12 * octave + scaleNotes[random(numScaleNotes)];
                }
            }
        }
        randomSeed(micros());
    }

    void generateScale(int* scaleNotes, int& numScaleNotes) override {
        numScaleNotes = random(5, 8);
        for (int i = 0; i < 12; i++) scaleNotes[i] = i;
        for (int i = 0; i < 12; i++) {
            int j = random(12);
            int temp = scaleNotes[i];
            scaleNotes[i] = scaleNotes[j];
            scaleNotes[j] = temp;
        }
        sortArray(scaleNotes, numScaleNotes);
    }

    void mutate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int intensity) override {
        // Swap call and response halves
        int half = numSteps / 2;
        for(int i=0; i<half; i++) {
            Step temp = sequence[track][i];
            sequence[track][i] = sequence[track][i+half];
            sequence[track][i+half] = temp;
        }
    }

    const char* getName() override {
        return "CallResp";
    }
};

#endif