using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xylem.Common.Hardware.Interfaces.Ports.PortCore;
using static GenesisCordonelInterface.API.InterfaceOutsideToGCI;
using static GenesisCordonelInterface.API.PublicModels;
using static Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore.GenesisMeter;

namespace GenesisCordonelInterface.API
{
    /// <summary>
    /// Public data contract layer for the Genesis Cordonel Interface (GCI).
    ///
    /// This class defines all Data Transfer Objects (DTOs) that are exposed
    /// to external consumers (e.g. TBF, UI, or other integration layers).
    ///
    /// Responsibilities:
    /// - Provide stable, dependency-free models for external usage
    /// - Decouple internal GCI implementation (GenesisMeter, Xylem libraries)
    ///   from external systems
    /// - Define request/response contracts for all supported operations
    /// - Contain mapping methods between public DTOs and internal domain models
    ///
    /// Architecture:
    /// External world (TBF / UI)
    ///     ↓
    /// GciPublicModels (this layer)
    ///     ↓
    /// Internal GCI API (InterfaceGCIToLaatzen, GenesisMeter, etc.)
    ///
    /// Notes:
    /// - Public models must NOT expose internal types (e.g. GenesisMeter, IPort, etc.)
    /// - All mapping between internal and external representations must be done here
    /// - DTOs are designed to be simple, serializable, and stable over time
    /// - Any change in internal implementation should not affect these models
    ///
    /// Pattern:
    /// Each operation follows a consistent structure:
    ///     Request  →  Operation  →  Result
    ///
    /// Example:
    ///     GciInitSlotRequest → InitSlot → GciInitSlotResult
    ///     GetSlot → GciSlotInfo
    ///     GetPcbId → GciGetPcbIdResult
    ///
    /// This layer acts as a boundary between domain logic and integration logic.
    /// </summary>
    public class ModelsMapping
    {
        /// <summary>
        /// Mapping methods between public DTOs and internal GCI models.
        /// Ensures separation between external contracts and internal domain objects.
        /// </summary>
        #region ================================== OUTERN/INTERN and back models mapping ==================================
        public static PasswordSource MapPasswordSource(PublicModels.GciPasswordSource src)
        {
            return (PasswordSource)src;
        }

        public static ConfigSource MapConfigSource(PublicModels.GciConfigSource src)
        {
            return (ConfigSource)src;
        }

        public static Xylem.Common.Hardware.Interfaces.Ports.PortCore.PortConfig? MapPort(PublicModels.GciPortConfig port)
        {
            if (port == null)
                return null;

            Xylem.Common.Hardware.Interfaces.Ports.PortCore.PortConfig result = new Xylem.Common.Hardware.Interfaces.Ports.PortCore.PortConfig();

            result.PortName = port.PortName;
            result.Type = port.Type;

            return result;
        }

        public static PublicModels.GciInitSlotResult MapInitResult(PublicModels.GciInitSlotResult result)
        {
            if (result == null)
                return null;

            return new PublicModels.GciInitSlotResult
            {
                SlotId = result.SlotId,
                Success = result.Success,
                Message = result.Message
            };
        }

        public static PublicModels.GciPasswordSource MapPasswordSourceBack(PasswordSource src)
        {
            return (PublicModels.GciPasswordSource)src;
        }

        public static PublicModels.GciConfigSource MapConfigSourceBack(ConfigSource src)
        {
            return (PublicModels.GciConfigSource)src;
        }

        public static PublicModels.GciPortConfig MapPortBack(PortConfig? port)
        {
            if (!port.HasValue)
                return null;

            PortConfig value = port.Value;

            return new PublicModels.GciPortConfig
            {
                PortName = value.PortName,
                Type = value.Type
            };
        }

        public static PublicModels.GciPortConfig MapPortBack(IPort port)
        {
            if (port == null)
                return null;

            return new PublicModels.GciPortConfig
            {
                PortName = port.GetPortName(),
                Type = port.GetType().Name
            };
        }

        public static PublicModels.GciPortConfig MapPortBack(string portName, string portTyoe)
        {
            return new PublicModels.GciPortConfig
            {
                PortName = portName,
                Type = portTyoe
            };
        }

        public static MeterBatchDebugStatus ToMeterBatchDebugStatus(GciSlotInfo slot)
        {
            if (slot == null)
                return null;

            return new MeterBatchDebugStatus
            {
                Slot = slot.SlotId,
                Selected = true,
                PcbId = slot.PcbId,
                IsConnected = false,
                IsLoggedOn = false,
                RequestPort = slot.RequestPort == null ? "" : slot.RequestPort.PortName,
                StreamingPort = slot.StreamingPort == null ? "" : slot.StreamingPort.PortName,
                FwVersion = "",
                InterfaceVersion = ""
            };
        }

        public static List<MeterBatchDebugStatus> ToMeterBatchDebugStatusList(
            IEnumerable<GciSlotInfo> slots)
        {
            if (slots == null)
                return new List<MeterBatchDebugStatus>();

            return slots
                .Where(x => x != null)
                .Select(ToMeterBatchDebugStatus)
                .ToList();
        }
        #endregion
    }
}