using BLAIzor.Models;
using BLAIzor.Services;
using Google.Cloud.Speech.V1;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Mvc;
using Microsoft.JSInterop;
using Radzen;
using System.Collections.Concurrent;
using System.Text;
using System.Text.Json;


namespace BLAIzor.Components.Pages
{
    public class MainPageBase : ComponentBase
    {
        public string SelectedBrandName = "default";
        [Inject] protected ScopedContentService _scopedContentService { get; set; }
        [Inject] protected ContentEditorService _contentEditorService { get; set; }
        [Inject] protected IConfiguration configuration { get; set; }
        [Inject] protected HttpClient Http { get; set; }
        [Inject] protected IJSRuntime jsRuntime { get; set; }
        [Inject] protected ISimpleLogger _logger { get; set; }
        [Inject] protected AIService ChatGptService { get; set; }
        [Inject] protected NotificationService NotificationService { get; set; }
        [Inject] protected CacheService CacheService { get; set; }

        public static readonly ConcurrentDictionary<string, MainPageBase> _instances = new();

        public string SessionId;

        public int SiteId;
        public SiteInfo SiteInfo;
        public StringBuilder HtmlContent = new StringBuilder("");
        public string TextContent = "";
        public string StatusContent = "";
        public string UserInput = string.Empty;
        public string TemplateCollectionName = "html_snippets";
        public string ContentCollectionName = "";

        public bool VoiceEnabled;
        public bool TTSEnabled;
        public bool STTEnabled;
        public bool _initVoicePending = false;
        public bool welcomeStage = true;
        public bool AiVoicePermitted = true;

        public string FirstColumnClass = "";
        public bool isEmailFormVisible = false;
        public ContactFormModel ContactFormModel = new();
        // private string? SuccessMessage;
        // private string? ErrorMessage;
        public string? DocumentEmailAddress = "";

        public string Menu;
        public List<MenuItem> MenuItems = new();
        public string dynamicallyLoadedCss = string.Empty;
        public MenuItem currentMenuItem = new();
        public bool IsContentSaved = false;


        public WebsiteContentModel SiteModel = new();

        public void DoSharedWork()
        {
            // Logic here
        }
        public void HandleBrandNameChanged()
        {
            SelectedBrandName = _scopedContentService.SelectedBrandName;
            try
            {
                StateHasChanged();
            }
            catch (Exception ex)
            {
                _ = _logger.ErrorAsync("HandleBrandNameChanged failed", ex.Message);
            }
        }

        public async Task<string> GetMenuList(int siteId)
        {
            List<MenuItem> menuItems = (await _contentEditorService.GetMenuItemsBySiteIdAsync(siteId)).Where(m => m.ShowInMainMenu == true).OrderBy(m => m.SortOrder).ToList();
            string menuList = "";
            foreach (MenuItem item in menuItems)
            {
                menuList += item.Name + ",";
            }
            return menuList;
        }

        public async Task<List<MenuItem>> GetMenuItems(int siteId)
        {
            List<MenuItem> menuItems = (await _contentEditorService.GetMenuItemsBySiteIdWithChildrenAsync(siteId)).Where(m => m.ShowInMainMenu == true).OrderBy(m => m.SortOrder).ToList();
            return menuItems;
        }


        private string GetApiKey() =>
            configuration?.GetSection("ElevenLabsAPI")?.GetValue<string>("ApiKey") ?? string.Empty;

        public async Task ConvertTextToSpeech(string textContent)
        {
            // string plainText = WebUtility.HtmlDecode(HtmlContent.ToString());

            if (string.IsNullOrWhiteSpace(textContent) || VoiceEnabled == false || TTSEnabled == false || welcomeStage || !AiVoicePermitted)
                return;

            Console.WriteLine("------------------------------OMGOMGOMG TTS call!!!!-------------");

            var requestContent = new
            {
                text = textContent,
                // model_id = "eleven_multilingual_v2",
                model_id = "eleven_flash_v2_5",
                voice_settings = new
                {
                    stability = 0.5,
                    similarity_boost = 0.75,
                    speed = 1.1
                }
            };

            var requestJson = JsonSerializer.Serialize(requestContent);
            string voiceId;
            if (SiteInfo.VoiceId != null)
            {
                voiceId = SiteInfo.VoiceId;
            }
            else
            {
                voiceId = "rE22Kc7UGoQj4zdHNYvd";
            }
            // string voiceId = "yyPLNYHg3CvjlSdSOdLh";

            var httpRequest = new HttpRequestMessage(HttpMethod.Post, $"https://api.elevenlabs.io/v1/text-to-speech/{voiceId}/stream")
            {
                Content = new StringContent(requestJson, Encoding.UTF8, "application/json")
            };

            httpRequest.Headers.Add("xi-api-key", GetApiKey());

            var response = await Http.SendAsync(httpRequest);
            if (response.IsSuccessStatusCode)
            {
                var audioBytes = await response.Content.ReadAsByteArrayAsync();
                var base64Audio = Convert.ToBase64String(audioBytes);
                var audioDataUrl = $"data:audio/mpeg;base64,{base64Audio}";

                await jsRuntime.InvokeVoidAsync("playAudio", audioDataUrl);
            }
            else
            {
                // Handle error response
                var errorContent = await response.Content.ReadAsStringAsync();
                Console.Error.WriteLine($"Error: {errorContent}");
            }
        }

        [JSInvokable("CallCSharpMethod2")]
        public static async Task CallCSharpMethod2(string input, string sessionId, bool forceUnModified = false)
        {
            // if (myHome != null)
            // {
            //     await myHome.HandleJsCall(input, );
            // }

            if (_instances.TryGetValue(sessionId, out var instance))
            {
                await instance.HandleJsCall(input, sessionId, forceUnModified);
            }
            Console.Write("Button clicked:" + input);
        }

        public async Task HandleJsCall(string input, string sessionId, bool forceUnmodified)
        {
            HtmlContent.Clear();
            await InvokeAsync(StateHasChanged);
            UserInput = input;
            await DisplayMenuContent(input, forceUnmodified);
            UserInput = string.Empty;
            await InvokeAsync(StateHasChanged);
        }

        public async Task HandleVoiceCommand(string input, string sessionId)
        {
            // HtmlContent = string.Empty;
            UserInput = input;
            await InvokeAsync(StateHasChanged);

            await SendUserQuery();
            //UserInput = string.Empty;
        }

        public async Task SendUserQuery()
        {
            welcomeStage = false;
            if (!string.IsNullOrEmpty(UserInput))
            {
                HtmlContent.Clear();
                var menu = await GetMenuList(SiteId);
                await ChatGptService.ProcessUserIntent(SessionId, UserInput, SiteId, (int)SiteInfo.TemplateId!, TemplateCollectionName, menu);
                UserInput = string.Empty;
            }
        }

        public virtual async Task DisplayMenuContent(string input, bool forceUnmodified)
        {
            welcomeStage = false;
            if (!string.IsNullOrEmpty(UserInput))
            {
                HtmlContent.Clear();
                var menu = await GetMenuList(SiteId);
                var menuList = await GetMenuItems(SiteId);

                var menuItem = CompareMenuItemNames(input, menuList);
                if (menuItem == null)
                {
                    await ChatGptService.ProcessContentRequest(SessionId, input, SiteId, (int)SiteInfo.TemplateId!, ContentCollectionName, menu, forceUnmodified);
                }
                else
                {
                    currentMenuItem = menuItem;
                    if (!string.IsNullOrEmpty(menuItem.StoredHtml))
                    {

                        HtmlContent.Clear();
                        HtmlContent.Append(menuItem.StoredHtml);
                        if (currentMenuItem.ContentItemId != null) {                         
                            var content = await _contentEditorService.GetContentItemByIdAsync((int)currentMenuItem.ContentItemId);
                            if (content != null)
                            {
                                string removedNumbers = TextHelper.ReplaceNumbersAndSpecialCharacters(content.Content, _scopedContentService.SelectedLanguage);
                                Console.WriteLine(removedNumbers);
                                UpdateTextContentForVoice(SessionId, removedNumbers);
                            }
                        }
                        IsContentSaved = true;
                    }
                    else
                    {
                        await ChatGptService.ProcessContentRequest(SessionId, menuItem, SiteId, (int)SiteInfo.TemplateId!, ContentCollectionName, menu, forceUnmodified);
                    }
                }
                UserInput = string.Empty;
            }
        }

        protected async void UpdateTextContentForVoice(string receivedSessionId, string content)
        {
            if (receivedSessionId != SessionId) return;
            TextContent = content;
            try
            {
                await ConvertTextToSpeech(content);
            }
            catch (Exception ex)
            {
                await _logger.ErrorAsync("UpdateTextContentForVoice failed", ex.Message);
            }
        }

        public async Task DisplayEmailForm(string emailAddress)
        {
            FirstColumnClass = "col-12 col-md-6";
            DocumentEmailAddress = emailAddress;
            isEmailFormVisible = true;
            StateHasChanged();
            var result = await jsRuntime.InvokeAsync<object>("getDivContent", "currentContent");
            _scopedContentService.CurrentDOM = JsonSerializer.Serialize(result);
            // Console.Write($"{_scopedContentService.CurrentDOM}");
        }

        [JSInvokable("ProcessAudio2")]
        public static async Task ProcessAudio2(string base64Audio, string sessionId)
        {
            if (!_instances.TryGetValue(sessionId, out var instance)) return;
            if (!instance.STTEnabled) return;

            var languageCode = instance._scopedContentService.SelectedLanguage switch
            {
                "English" => "en-US",
                "German" => "de-DE",
                _ => "hu-HU"
            };

            var credentialsPath = instance.configuration.GetSection("GoogleAPI").GetValue<string>("CredentialsPath");
            var speech = new SpeechClientBuilder { CredentialsPath = credentialsPath }.Build();

            byte[] audioBytes = Convert.FromBase64String(base64Audio);
            instance.HtmlContent.Clear();

            var response = await speech.RecognizeAsync(new RecognitionConfig
            {
                Encoding = RecognitionConfig.Types.AudioEncoding.Mp3,
                SampleRateHertz = 48000,
                LanguageCode = languageCode
            }, RecognitionAudio.FromBytes(audioBytes));

            foreach (var result in response.Results)
            {
                foreach (var alternative in result.Alternatives)
                {
                    await instance.HandleVoiceCommand(alternative.Transcript, sessionId);
                }
            }
        }

        [JSInvokable("OpenEmailForm2")]
        public static async Task OpenEmailForm2(string emailAddress, string sessionId)
        {
            if (_instances.TryGetValue(sessionId, out var instance))
            {
                await instance.DisplayEmailForm(emailAddress);
            }
        }

        public async Task SendMessage()
        {
            Console.WriteLine("Button clicked!");
            var menu = await GetMenuList(SiteId);
            HtmlContent.Clear();
            await ChatGptService.ProcessUserIntent(SessionId, UserInput, SiteId, (int)SiteInfo.TemplateId!, ContentCollectionName, menu);
            UserInput = string.Empty;
        }

        public MenuItem CompareMenuItemNames(string input, List<MenuItem> menuList)
        {
            var parent = menuList.FirstOrDefault(ml => ml.Name == input);
            if (parent != null)
            {
                return parent;
            }

            foreach (var item in menuList)
            {
                var child = item.Children.FirstOrDefault(ch => ch.Name == input);
                if (child != null)
                {
                    return child;
                }
            }
            return null; // or throw, or return a default
        }

        public void ShowNotification(NotificationMessage message)
        {
            NotificationService.Notify(message);
        }

        public async ValueTask DisposeAsync()
        {
            _instances.TryRemove(SessionId, out _);
            _scopedContentService.OnBrandNameChanged -= HandleBrandNameChanged;
            ChatGptService.OnTextContentAvailable -= UpdateTextContentForVoice;
        }

    }
}