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

namespace xAiApi.Providers
{
    public abstract class XAIServiceBase : IXAiServiceBase
    {
        /// <summary>
        /// Chat Options ...
        /// </summary>
        public ChatOptions Options { get; }

        /// <summary>
        /// Descriptor of Models which used in Service ...
        /// </summary>        
        public XAiModelDescriptor Descriptor { get; }

        private readonly IXAiDataProvider dataProvider;
        private readonly ILogger<XAIServiceBase> logger;
        private readonly XAiApiConfiguration configuration;

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

            //
            // Prepare Embedding Model Descriptor ...
            Descriptor = configuration.GetModel(model);
            if (!Descriptor.IsValid())
            {
                XException.InvalidConfiguration.Throw();
            }

            //
            // Prepare Chat Options based On Tools ...
            Options = new ChatOptions();
        }

        //
        #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> AskTextAsync(
            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;

            //
            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> AskTextAsEnumerable(
            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
            );

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

                //
                yield return res.Text;
            }
        }

        /// <summary>
        /// Get LLM Client instance for Communicating with LLM ...
        /// </summary>
        /// <returns></returns>
        public virtual IChatClient GetClient()
        {
            //
            // Try to Initialize LLm ...
            var model = Descriptor.LLM;
            var apiKey = Descriptor.ApiKey;
            var url = new Uri(Descriptor.Url);
            var httpClient = GetHttpClient(Descriptor.Url);

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

                //
                case XAiModelProviderType.OpenAI:
                    //
                    // Instance Ollama Client using Custom HttpCLient ...
                    var openAiClient = new OpenAIClient(
                        new ApiKeyCredential(apiKey.IsNullOrEmpty() ? XAiApiConstants.XOpenAINoKey : apiKey),
                        new OpenAIClientOptions
                        {
                            Endpoint = url,
                            Transport = new HttpClientPipelineTransport(httpClient)
                        }
                    );
                    result =
                        new ChatClientBuilder(
                            openAiClient
                            .GetChatClient(model)
                        .AsIChatClient())
                        .UseFunctionInvocation()
                        .Build();
                    break;

                //
                case XAiModelProviderType.DeepSeek:
                    break;

                //
                case XAiModelProviderType.HuggingFace:
                    break;

                //
                default:
                    break;
            }

            //
            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,
                configuration.GetPrompt()
            );

            //
            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,
                configuration.GetPrompt(XAiApiConstants.XAiApiIntroductionPromptName)
            );

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

            //
            return result;
        }
        #endregion

        //
        #region Data Provider Based Actions ...
        public async Task<IEnumerable<XAiProjectDto>> LoadProjects(
            string ownerId,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Validate Args ...
            if (ownerId.IsNullOrEmpty())
            {
                XException.InvalidArgs.Throw();
            }

            //
            var result = await dataProvider.LoadProjects(
                ownerId: ownerId,
                cancellationToken: cancellationToken
            );

            //
            // Here we have to fill Conversations of Default Project ...
            var defaultProjectId = result.GetDafualtProject(ownerId);
            
            //
            // Reading Conversations of Specified Default Project ...
            var conversations = await dataProvider.LoadConversations(
                fillMessages: false,
                projectId: defaultProjectId,
                cancellationToken: cancellationToken
            );
            var defaultConversationId = conversations.GetDefaultConversation(
                ownerId: ownerId,
                projectId: defaultProjectId
            );

            //
            return result;
        }
        #endregion

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