using NAudio.CoreAudioApi;
using NAudio.CoreAudioApi.Interfaces;
using Serilog;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Windows.Threading;

namespace WorkIndicator;

internal class AudioDevice : IAudioSessionEventsHandler
{
    private readonly ILogger _logger;
    private readonly MMDevice _device;
    private readonly Dispatcher _dispatcher;
    private readonly Dictionary<string, AudioSessionControl> _sessions = new();

    public delegate void AudioSessionsChangedDelegate();

    public event AudioSessionsChangedDelegate AudioSessionsChanged;

    public AudioDevice(MMDevice device)
    {
        _logger = Log.ForContext<AudioDevice>();

        _dispatcher = Dispatcher.CurrentDispatcher;

        _device = device;

        _device.AudioSessionManager.AudioSessionControl.RegisterEventClient(this);
        _device.AudioSessionManager.OnSessionCreated += AudioSessionManager_OnSessionCreated;

        _device.AudioSessionManager.RefreshSessions();
        var sessions = _device.AudioSessionManager.Sessions;

        for (var i = 0; i < sessions.Count; i++)
        {
            SetupSession(sessions[i]);
        }
    }

    private void AudioSessionManager_OnSessionCreated(object sender, IAudioSessionControl newSession)
    {
        var session = new AudioSessionControl(newSession);

        _logger.Information("OnSessionCreated: {name}", session.GetSessionIdentifier);

        SetupSession(session);
    }

    private void SetupSession(AudioSessionControl session)
    {
        _logger.Information("SetupSession: {name}", session.GetSessionIdentifier);

        _sessions[session.GetSessionIdentifier] = session;
        session.RegisterEventClient(this);

        AudioSessionsChanged?.Invoke();
    }

    public int ActiveSessionCount => _sessions.Values.Count(s => s.State == AudioSessionState.AudioSessionStateActive);

    void IAudioSessionEventsHandler.OnVolumeChanged(float volume, bool isMuted)
    {
        _dispatcher.Invoke(() => { Debug.WriteLine($"{_device.DeviceFriendlyName}: {volume} {isMuted} {_device.AudioEndpointVolume.Mute}"); });
    }

    void IAudioSessionEventsHandler.OnDisplayNameChanged(string displayName)
    {
        _logger.Information("OnDisplayNameChanged: {name}", displayName);
    }

    void IAudioSessionEventsHandler.OnIconPathChanged(string iconPath)
    {
        _logger.Information("OnIconPathChanged: {path}", iconPath);
    }

    void IAudioSessionEventsHandler.OnChannelVolumeChanged(uint channelCount, IntPtr newVolumes, uint channelIndex)
    {
        _logger.Information("OnChannelVolumeChanged: {channelCount} {newVolumes} {channelIndex}", channelCount, newVolumes, channelIndex);
    }

    void IAudioSessionEventsHandler.OnGroupingParamChanged(ref Guid groupingId)
    {
        _logger.Information("OnGroupingParamChanged: {groupingId}", groupingId);
    }

    void IAudioSessionEventsHandler.OnStateChanged(AudioSessionState state)
    {
        _logger.Information("OnStateChanged: {state}", state);

        AudioSessionsChanged?.Invoke();

        if (state == AudioSessionState.AudioSessionStateExpired)
        {
        }
    }

    void IAudioSessionEventsHandler.OnSessionDisconnected(AudioSessionDisconnectReason disconnectReason)
    {
        _logger.Information("OnSessionDisconnected: {disconnectReason}", disconnectReason);
    }
}