using DiscordRPC;
using System;
using System.IO;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

class Program
{
    private const string ConfigFilePath = "config.json";
    private static DiscordRpcClient _discordClient;
    private static Config _config;
    private static bool isScreenSharing = false;  // Track screen sharing status

    // Hard-code the Discord Client ID here
    private const string DiscordClientId = "1312264302601834578"; // Replace with your actual Discord client ID

    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting Jellyfin Discord Rich Presence...");

        // Load or create configuration
        LoadOrCreateConfig();

        // Initialize Discord Rich Presence
        _discordClient = new DiscordRpcClient(DiscordClientId);
        _discordClient.OnReady += (sender, e) => Console.WriteLine("Connected to Discord RPC!");
        _discordClient.OnPresenceUpdate += (sender, e) => Console.WriteLine("Rich Presence updated!");
        _discordClient.Initialize();

        // Poll Jellyfin API for currently playing media
        var updateTask = UpdateRichPresence();  // Start the rich presence update task

        // Command loop for toggling screen sharing
        while (true)
        {
            var command = Console.ReadLine()?.ToLower();
            if (command == "toggle")
            {
                ToggleScreenSharing();
            }
            else if (command == "exit")
            {
                break;  // Exit the loop and end the program
            }
            else
            {
                Console.WriteLine("Invalid command. Type 'toggle' to toggle screen sharing or 'exit' to quit.");
            }
        }

        await updateTask;  // Wait for the rich presence update task to finish
    }

    private static void ToggleScreenSharing()
    {
        isScreenSharing = !isScreenSharing;  // Toggle the screen sharing state
        Console.WriteLine(isScreenSharing ? "Screen sharing enabled." : "Screen sharing disabled.");
        UpdateDiscordPresence();  // Manually update Discord presence when toggling screen sharing
    }

    private static void UpdateDiscordPresence()
    {
        // Log the current status of screen sharing
        Console.WriteLine($"Updating Discord Presence. Screen Sharing: {isScreenSharing}");

        // Ensure we immediately update the Discord presence when toggling screen sharing
        _discordClient.SetPresence(new RichPresence
        {
            Details = isScreenSharing ? "Sharing screen" : "Watching media",
            State = isScreenSharing ? "Screen sharing is active" : "Not sharing screen",
            Timestamps = new Timestamps
            {
                Start = DateTime.UtcNow
            },
            Assets = new Assets
            {
                LargeImageKey = isScreenSharing ? "screen_sharing" : "media_playing",
                LargeImageText = isScreenSharing ? "Screen sharing on Discord" : "Watching media on Jellyfin"
            }
        });

        Console.WriteLine("Presence updated successfully.");
    }

    private static async Task UpdateRichPresence()
    {
        while (true)
        {
            try
            {
                var playingInfo = await GetCurrentlyPlaying().ConfigureAwait(false);
                if (playingInfo != null)
                {
                    JToken nowPlaying = playingInfo.NowPlayingItem;

                    string largeImageKey = playingInfo.IsMusic
                        ? await GetAlbumCover(nowPlaying).ConfigureAwait(false)
                        : await GetJellyfinLogo().ConfigureAwait(false);
                    string largeImageText = playingInfo.IsMusic
                        ? nowPlaying["Album"]?.ToString() ?? "Unknown Album"
                        : "Jellyfin Media Player";

                    string details = playingInfo.IsMusic
                        ? $"{playingInfo.Title}" // Show song name
                        : $"Watching: {playingInfo.Title}"; // Show video title

                    string state = isScreenSharing ? "Sharing screen" : playingInfo.IsMusic
                        ? $"{playingInfo.Artist}"  // Show artist name
                        : $"Season {playingInfo.Season}, Episode {playingInfo.Episode}";

                    Console.WriteLine($"Updating presence with details: {details}, state: {state}");

                    _discordClient.SetPresence(new RichPresence
                    {
                        Details = details,
                        State = state,  // Dynamic state based on screen sharing or media
                        Timestamps = new Timestamps
                        {
                            Start = DateTime.UtcNow - playingInfo.Progress,
                            End = DateTime.UtcNow + (playingInfo.Duration - playingInfo.Progress)
                        },
                        Assets = new Assets
                        {
                            LargeImageKey = largeImageKey,
                            LargeImageText = largeImageText
                        }
                    });
                }
                else
                {
                    _discordClient.ClearPresence();
                    Console.WriteLine("No media playing, clearing presence.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error fetching Jellyfin data: {ex.Message}");
            }

            // Wait before polling again
            await Task.Delay(5000).ConfigureAwait(false);
        }
    }

    private static async Task<string> GetJellyfinLogo()
    {
        using var httpClient = new HttpClient();
        try
        {
            var response = await httpClient.GetAsync($"{_config.JellyfinBaseUrl}/System/Info?api_key={_config.JellyfinApiKey}").ConfigureAwait(false);
            response.EnsureSuccessStatusCode();

            var jsonResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
            var json = JObject.Parse(jsonResponse);

            var logoUrl = json["LogoUrl"]?.ToString();
            return logoUrl ?? "jellyfin_logo";
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error fetching Jellyfin logo: {ex.Message}");
            return "jellyfin_logo"; // Default fallback
        }
    }

    private static void LoadOrCreateConfig()
    {
        if (File.Exists(ConfigFilePath))
        {
            var configJson = File.ReadAllText(ConfigFilePath);
            _config = JsonSerializer.Deserialize<Config>(configJson);
        }
        else
        {
            _config = new Config();
            Console.Write("Enter Jellyfin Server URL: ");
            _config.JellyfinBaseUrl = Console.ReadLine();
            Console.Write("Enter Jellyfin API Key: ");
            _config.JellyfinApiKey = Console.ReadLine();
            Console.Write("Enter Jellyfin User ID: ");
            _config.JellyfinUserId = Console.ReadLine();

            var configJson = JsonSerializer.Serialize(_config, new JsonSerializerOptions { WriteIndented = true });
            File.WriteAllText(ConfigFilePath, configJson);
            Console.WriteLine("Configuration saved to config.json.");
        }
    }

    private static async Task<PlayingInfo?> GetCurrentlyPlaying()
    {
        using var httpClient = new HttpClient();
        try
        {
            var response = await httpClient.GetAsync($"{_config.JellyfinBaseUrl}/Sessions?api_key={_config.JellyfinApiKey}").ConfigureAwait(false);
            response.EnsureSuccessStatusCode();

            var jsonResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
            var sessions = JArray.Parse(jsonResponse);

            foreach (var session in sessions)
            {
                if (session["UserId"]?.ToString() == _config.JellyfinUserId && session["NowPlayingItem"] != null)
                {
                    var nowPlaying = session["NowPlayingItem"];
                    var mediaType = nowPlaying["Type"]?.ToString();
                    bool isMusic = mediaType?.ToLower() == "audio";

                    string albumCover = "";
                    string artist = "Unknown Artist";

                    if (isMusic)
                    {
                        albumCover = await GetAlbumCover(nowPlaying).ConfigureAwait(false);
                        var artists = nowPlaying["Artists"]?.ToObject<JArray>();
                        if (artists != null && artists.Count > 0)
                        {
                            artist = artists[0].ToString();
                        }
                    }
                    else
                    {
                        artist = "Unknown Artist";
                    }

                    return new PlayingInfo
                    {
                        Title = nowPlaying["Name"]?.ToString(),
                        Artist = artist,
                        AlbumCover = albumCover,
                        Season = nowPlaying["ParentIndexNumber"]?.ToString() ?? "N/A",
                        Episode = nowPlaying["IndexNumber"]?.ToString() ?? "N/A",
                        Progress = TimeSpan.FromTicks((long)session["PlayState"]["PositionTicks"]),
                        Duration = TimeSpan.FromTicks((long)nowPlaying["RunTimeTicks"]),
                        IsMusic = isMusic,
                        NowPlayingItem = nowPlaying
                    };
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error fetching Jellyfin data: {ex.Message}");
        }

        return null;
    }

    private static async Task<string> GetAlbumCover(JToken nowPlaying)
    {
        var mediaStreams = nowPlaying["MediaStreams"]?.ToObject<JArray>();
        if (mediaStreams != null)
        {
            foreach (var stream in mediaStreams)
            {
                var imageTag = stream["ImageTag"]?.ToString();
                if (!string.IsNullOrEmpty(imageTag))
                {
                    return imageTag;  // Return the album cover image tag
                }
            }
        }
        return "album_cover";
    }
}

class Config
{
    public string JellyfinBaseUrl { get; set; }
    public string JellyfinApiKey { get; set; }
    public string JellyfinUserId { get; set; }
}

class PlayingInfo
{
    public string Title { get; set; }
    public string Artist { get; set; }
    public string AlbumCover { get; set; }
    public string Season { get; set; }
    public string Episode { get; set; }
    public TimeSpan Progress { get; set; }
    public TimeSpan Duration { get; set; }
    public bool IsMusic { get; set; }
    public JToken NowPlayingItem { get; set; }
}