A!leys Galerie

using UnityEngine;
using UnityEngine.Audio;
using System.Collections;
using System.Linq;

[RequireComponent(typeof(AudioSource))]
public class SmoothSyncAudioMixer : MonoBehaviour
{
    [Header("Audio Sources")]
    [SerializeField] private AudioClip[] audioClips;
    [SerializeField] private float crossfadeDuration = 1.0f;
    [SerializeField] private float intensityRange = 0.5f;
    [SerializeField] private float tempoSyncThreshold = 0.8f;

    [Header("Dynamic Effects")]
    [SerializeField] private bool enableIntensityModulation = true;
    [SerializeField] private bool enableTempoSync = true;
    [SerializeField] private float minIntensity = 0.3f;
    [SerializeField] private float maxIntensity = 1.0f;

    [Header("Visual Feedback")]
    [SerializeField] private Material visualFeedbackMaterial;
    [SerializeField] private Renderer[] visualFeedbackRenderers;

    private AudioSource _audioSource;
    private float _currentIntensity = 1.0f;
    private float _targetIntensity = 1.0f;
    private float _crossfadeProgress = 0.0f;
    private int _currentClipIndex = 0;
    private int _nextClipIndex = 1;
    private bool _isCrossfading = false;
    private float _tempoSyncFactor = 1.0f;

    private void Awake()
    {
        _audioSource = GetComponent<AudioSource>();
        if (visualFeedbackMaterial != null && visualFeedbackRenderers.Length == 0)
        {
            Debug.LogWarning("Visual feedback material assigned but no renderers specified. Disabling visual feedback.");
            visualFeedbackMaterial = null;
        }
    }

    private void Start()
    {
        if (audioClips.Length < 2)
        {
            Debug.LogError("At least two audio clips are required for crossfading. Disabling crossfade functionality.");
            return;
        }

        PlayNextClip();
    }

    private void Update()
    {
        if (_isCrossfading)
        {
            _crossfadeProgress += Time.deltaTime / crossfadeDuration;
            if (_crossfadeProgress >= 1.0f)
            {
                _crossfadeProgress = 1.0f;
                _isCrossfading = false;
                _currentClipIndex = _nextClipIndex;
                PlayNextClip();
            }

            if (enableIntensityModulation)
            {
                UpdateIntensity();
            }

            if (enableTempoSync)
            {
                UpdateTempoSync();
            }

            UpdateVisualFeedback();
        }
        else
        {
            if (enableIntensityModulation)
            {
                UpdateIntensity();
            }

            if (enableTempoSync)
            {
                UpdateTempoSync();
            }
        }
    }

    private void PlayNextClip()
    {
        if (audioClips.Length < 2) return;

        _nextClipIndex = (_currentClipIndex + 1) % audioClips.Length;
        _isCrossfading = true;
        _crossfadeProgress = 0.0f;
        _audioSource.PlayOneShot(audioClips[_currentClipIndex], _targetIntensity);

        StartCoroutine(CrossfadeToNext());
    }

    private IEnumerator CrossfadeToNext()
    {
        while (_crossfadeProgress < 1.0f)
        {
            yield return null;
        }

        _audioSource.PlayOneShot(audioClips[_nextClipIndex], _targetIntensity);
    }

    private void UpdateIntensity()
    {
        if (Mathf.Abs(_targetIntensity - _currentIntensity) > 0.01f)
        {
            _currentIntensity = Mathf.Lerp(_currentIntensity, _targetIntensity, Time.deltaTime * 5f);
        }
    }

    private void UpdateTempoSync()
    {
        float currentBpm = CalculateBpm();
        float targetBpm = 120f; // Default target tempo

        // Find the closest clip to our target tempo
        AudioClip closestClip = null;
        float minBpmDifference = float.MaxValue;
        foreach (var clip in audioClips)
        {
            if (clip == null) continue;
            float clipBpm = CalculateBpm(clip);
            float bpmDifference = Mathf.Abs(clipBpm - targetBpm);
            if (bpmDifference < minBpmDifference)
            {
                minBpmDifference = bpmDifference;
                closestClip = clip;
            }
        }

        if (closestClip != null && minBpmDifference < tempoSyncThreshold * targetBpm)
        {
            _tempoSyncFactor = Mathf.Lerp(_tempoSyncFactor, 1.0f, Time.deltaTime * 2f);
            _targetIntensity = Mathf.Lerp(_targetIntensity, maxIntensity, Time.deltaTime * 3f);
        }
        else
        {
            _tempoSyncFactor = Mathf.Lerp(_tempoSyncFactor, 0.7f, Time.deltaTime * 2f);
            _targetIntensity = Mathf.Lerp(_targetIntensity, minIntensity, Time.deltaTime * 3f);
        }

        _audioSource.pitch = _tempoSyncFactor;
    }

    private float CalculateBpm(AudioClip clip = null)
    {
        AudioClip currentClip = clip ?? audioClips[_currentClipIndex];
        if (currentClip == null) return 120f;

        float[] samples = new float[currentClip.samples];
        currentClip.GetData(samples, 0);

        float maxAmplitude = 0;
        int peaks = 0;
        float peakInterval = 0;
        float lastPeakTime = 0;

        for (int i = 0; i < samples.Length; i++)
        {
            float absValue = Mathf.Abs(samples[i]);
            if (absValue > maxAmplitude)
            {
                maxAmplitude = absValue;
            }
        }

        if (maxAmplitude < 0.001f) return 120f;

        float threshold = 0.5f * maxAmplitude;
        float currentTime = 0;

        for (int i = 0; i < samples.Length; i++)
        {
            float absValue = Mathf.Abs(samples[i]);
            if (absValue > threshold)
            {
                if (peakInterval == 0)
                {
                    peakInterval = currentTime - lastPeakTime;
                    lastPeakTime = currentTime;
                    peaks++;
                }
            }
            currentTime += (1.0f / (currentClip.frequency * currentClip.channels));
        }

        if (peaks < 2) return 120f;
        return 60f / (peakInterval / currentClip.samples * currentClip.frequency);
    }

    private void UpdateVisualFeedback()
    {
        if (visualFeedbackMaterial == null) return;

        float intensityColorFactor = Mathf.Clamp01(_currentIntensity * 2f);
        Color color = Color.Lerp(Color.red, Color.blue, intensityColorFactor);
        visualFeedbackMaterial.color = color;

        foreach (var renderer in visualFeedbackRenderers)
        {
            if (renderer != null)
            {
                renderer.material = visualFeedbackMaterial;
            }
        }
    }

    // For debugging purposes
    private void OnGUI()
    {
        GUILayout.BeginArea(new Rect(10, 10, 200, 100));
        GUILayout.Label($"Current Clip: {_currentClipIndex}");
        GUILayout.Label($"Next Clip: {_nextClipIndex}");
        GUILayout.Label($"Intensity: {_currentIntensity:F2}");
        GUILayout.Label($"Crossfade: {(int)(_crossfadeProgress * 100)}%");
        GUILayout.Label($"Tempo Factor: {_tempoSyncFactor:F2}");
        GUILayout.EndArea();
    }
}