using System;
using System.Threading;
using xAiApi.Interfaces;
using xCommons.Extensions;
using xAiModels.Interfaces;
using xExceptions.Constants;
using System.Threading.Tasks;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;
using System.Runtime.CompilerServices;
using Microsoft.Extensions.AI;
using xAiModels.Extensions;
using xAiApi.Configurations;
using xAiApi.Extensions;
using System.Net.Http;
using OllamaSharp;

namespace xAiApi.Providers
{
    public abstract class XAIServiceBase : IXAIServiceBase
    {
        private readonly IXAiDataProvider dataProvider;
        private readonly ILogger<XAIServiceBase> logger;
        private readonly XAiApiConfiguration configuration;

        protected XAIServiceBase(
            IXAiDataProvider dataProvider,
            ILogger<XAIServiceBase> logger,
            XAiApiConfiguration configuration
        )
        {
            this.logger = logger;
            this.dataProvider = dataProvider;
            this.configuration = configuration;
        }

        //
        #region Actions ...
        /// <summary>
        /// Base Method for Communicate with LLM ...
        /// </summary>
        /// <param name="prompt"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<string> AskAsync(
            string prompt,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Check Prompt Exists ...
            if (prompt.IsNullOrEmpty())
            {
                XException.InvalidArgs.Throw();
            }

            //
            using var client = GetClient();
            var history = GetHistory(prompt);
            var response = await client.GetResponseAsync(
                messages: history,
                cancellationToken: cancellationToken
            );

            //
            // Validate Response ...
            if (!response.IsValid())
            {
                //
                // Dispose Client ...
                client.Dispose();
                XException.ActionFailed.Throw();
            }

            //
            // Retrieve Response Text ...
            var result = response.Text;

            //
            // Dispose Client ...
            client.Dispose();

            //
            return result;
        }

        /// <summary>
        /// Base Method for Communicate with LLM ...
        /// </summary>
        /// <param name="prompt"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async IAsyncEnumerable<string> AskAsEnumerable(
            string prompt,
            [EnumeratorCancellation]
            CancellationToken cancellationToken = default
        )
        {
            //
            // Check Prompt Exists ...
            if (prompt.IsNullOrEmpty())
            {
                XException.InvalidArgs.Throw();
            }

            //
            using var client = GetClient();
            var history = GetHistory(prompt);
            var enumerable = client.GetStreamingResponseAsync(
                options: null,
                messages: history
            );

            //
            var result = "";
            await foreach (var res in enumerable)
            {
                //
                // Cancellation Token ...
                if (cancellationToken.IsCancellationRequested)
                {
                    yield break;
                }

                //
                result += res.Text;
            }

            //
            // Dispose Client ...
            client.Dispose();

            //
            yield return result;
        }

        /// <summary>
        /// Get LLM Client instance for Communicating with LLM ...
        /// </summary>
        /// <param name="llm"></param>
        /// <returns></returns>
        public virtual IChatClient GetClient(string llm = null)
        {
            //
            // Retrieve Model Descriptor ...
            var modelDescriptor = configuration.GetModel(llm);
            if (modelDescriptor.IsNullOrDefault())
            {
                XException.NotFound.Throw();
            }

            //
            // Try to Initialize LLm ...
            var model = modelDescriptor.LLM;
            var apiKey = modelDescriptor.ApiKey;
            var url = new Uri(modelDescriptor.Url);
            var httpClient = GetHttpClient(modelDescriptor.Url);

            //
            IChatClient result = null;
            switch (modelDescriptor.Provider)
            {
                //
                case Constants.XAiProvider.Ollama:
                    //
                    // Instance Ollama Client using Custom HttpCLient ...
                    var ollamaClient = new OllamaApiClient(httpClient, model);
                    result =
                        new ChatClientBuilder(ollamaClient)
                        .Build();
                    break;

                //
                case Constants.XAiProvider.DeepSeek:
                    break;

                //
                case Constants.XAiProvider.HuggingFace:
                    break;

                //
                default:
                    break;
            }

            // //
            // if (isOllamaBased)
            // {
            // }
            // else if (isDeepSeekBased)
            // {
            //     //
            //     if (apiKey is null ||
            //         string.IsNullOrWhiteSpace(apiKey))
            //     {
            //         throw new Exception("Inavlid Args ...");
            //     }

            //     //
            //     var deepseekClient = new DeepSeekChatClient(apiKey: apiKey);
            //     result = deepseekClient;
            // }
            // else
            // {
            //     //
            //     // TODO: Implement this ...
            // }

            //
            if (result.IsNullOrDefault())
            {
                XException.InvalidData.Throw();
            }

            //
            return result;
        }

        /// <summary>
        /// Create Custom HttpClient for Communicating with LLM API ...
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public virtual HttpClient GetHttpClient(string url = null)
        {
            //
            var result = new HttpClient
            {
                //
                // Disable timeout completely (not recommended for production)
                Timeout = Timeout.InfiniteTimeSpan,

                //
                BaseAddress = url.IsNullOrEmpty()
                    ? null
                    : new Uri(url),

                //
                // OR set a very long timeout (e.g., 30 minutes for large file uploads)
                // Timeout = TimeSpan.FromMinutes(30)
            };

            //
            return result;
        }

        /// <summary>
        /// Prepare a Message History List for LLM Communication based on Prompt ...
        /// </summary>
        /// <param name="prompt"></param>
        /// <param name="forcePrompt"></param>
        /// <returns></returns>
        public virtual IList<ChatMessage> GetHistory(
            string prompt = null,
            bool forcePrompt = true
        )
        {
            //
            // Validate Args ...
            if (prompt.IsNullOrEmpty())
            {
                XException.InvalidArgs.Throw();
            }

            //
            // User Prompt ...
            var promptMessage = new ChatMessage(
                ChatRole.User,
                prompt
            );

            //
            // Preparing Introduction Prompt ...
            var introductionPrompt = new ChatMessage(
                ChatRole.System,
                PromptHelper.GetIntroductionPrompt().Prompt
            );

            //
            List<ChatMessage> result =
            [
                introductionPrompt,
            ];
            if (forcePrompt &&
                prompt is not null &&
                !string.IsNullOrWhiteSpace(prompt))
            {
                result.Add(promptMessage);
            }

            //
            return result;
        }

        /// <summary>
        /// Prepare a Message History List for LLM Communication based on Prompt ...
        /// </summary>
        /// <param name="message"></param>
        /// <param name="forceMessage"></param>
        /// <returns></returns>
        public virtual IList<ChatMessage> GetHistory(
            ChatMessage message = null,
            bool forceMessage = true
        )
        {
            //
            // Preparing Introduction Prompt ...
            var introductionPrompt = new ChatMessage(
                ChatRole.System,
                PromptHelper.GetIntroductionPrompt().Prompt
            );

            //
            List<ChatMessage> result =
            [
                introductionPrompt,
            ];
            if (forceMessage &&
                message is not null)
            {
                result.Add(message);
            }

            //
            return result;
        }
        #endregion

        /// <summary>
        /// Base Dispose Action ...
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        public virtual void Dispose()
        { }
    }
}