using System;
using System.Collections.Generic;
using System.Linq;

namespace rgbc_sds.services.Models
{
    /// <summary>
    /// Raw data from an Excel row during import
    /// </summary>
    public class ExcelRowData
    {
        /// <summary>
        /// Row number in the Excel file (1-based)
        /// </summary>
        public int RowNumber { get; set; }

        /// <summary>
        /// Dictionary of column values by header name
        /// </summary>
        public Dictionary<string, string> ColumnValues { get; set; } = new Dictionary<string, string>();

        /// <summary>
        /// Whether this row has any data
        /// </summary>
        public bool HasData => ColumnValues.Values.Any(v => !string.IsNullOrWhiteSpace(v));

        /// <summary>
        /// Gets a column value by header name
        /// </summary>
        /// <param name="headerName">Column header name</param>
        /// <returns>Column value or empty string if not found</returns>
        public string GetValue(string headerName)
        {
            return ColumnValues.TryGetValue(headerName, out var value) ? value : string.Empty;
        }

        /// <summary>
        /// Gets a column value by header name with fallback
        /// </summary>
        /// <param name="headerName">Column header name</param>
        /// <param name="fallbackValue">Fallback value if column not found</param>
        /// <returns>Column value or fallback value</returns>
        public string GetValue(string headerName, string fallbackValue)
        {
            return ColumnValues.TryGetValue(headerName, out var value) ? value : fallbackValue;
        }

        /// <summary>
        /// Checks if a column exists and has a value
        /// </summary>
        /// <param name="headerName">Column header name</param>
        /// <returns>True if column exists and has non-empty value</returns>
        public bool HasValue(string headerName)
        {
            return ColumnValues.TryGetValue(headerName, out var value) && !string.IsNullOrWhiteSpace(value);
        }
    }

    /// <summary>
    /// Column mapping information for Excel import
    /// </summary>
    public class ColumnMapping
    {
        /// <summary>
        /// Expected column headers in the Excel file
        /// </summary>
        public static readonly string[] ExpectedHeaders = new[]
        {
            "Supplier",
            "Indent Number",
            "Shipshape Number",
            "Mother Vessel",
            "E.T.A",
            "Bill of Entry Number",
            "Container Number",
            "Offloading Port",
            "Container Received",
            "No of Flatcases",
            "Voyage",
            "M/BL Number",
            "Redirect to SACD"
        };

        /// <summary>
        /// Maps Excel column headers to entity property names
        /// </summary>
        public static readonly Dictionary<string, string> HeaderToPropertyMap = new()
        {
            { "Supplier", "SupplierName" },
            { "Indent Number", "IndentNumber" },
            { "Shipshape Number", "ShipshapeNumber" },
            { "Mother Vessel", "MotherVessel" },
            { "E.T.A", "ETA" },
            { "Bill of Entry Number", "BillOfEntryNumber" },
            { "Container Number", "ContainerNumber" },
            { "Offloading Port", "OffloadingPort" },
            { "Container Received", "ContainerReceived" },
            { "No of Flatcases", "NoOfFlatcases" },
            { "Voyage", "Voyage" },
            { "M/BL Number", "MBLNumber" },
            { "Redirect to SACD", "RedirectToSACD" }
        };

        /// <summary>
        /// Required columns that must be present
        /// </summary>
        public static readonly string[] RequiredColumns = new[]
        {
            "Supplier",
            "Indent Number",
            "Shipshape Number",
            "Mother Vessel",
            "E.T.A",
            "Bill of Entry Number",
            "Container Number",
            "Offloading Port",
            "Container Received",
            "No of Flatcases",
            "Voyage",
            "M/BL Number",
            "Redirect to SACD"
        };

        /// <summary>
        /// Date columns that need special parsing
        /// </summary>
        public static readonly string[] DateColumns = new[]
        {
            "E.T.A",
            "Container Received",
            "Redirect to SACD"
        };

        /// <summary>
        /// Validates that all required columns are present
        /// </summary>
        /// <param name="foundHeaders">Headers found in the Excel file</param>
        /// <returns>Validation result with missing columns</returns>
        public static ColumnValidationResult ValidateHeaders(IEnumerable<string> foundHeaders)
        {
            var foundHeadersSet = foundHeaders.Select(h => h.Trim()).ToHashSet(StringComparer.OrdinalIgnoreCase);
            var missingColumns = RequiredColumns
                .Where(required => !foundHeadersSet.Contains(required))
                .ToList();

            return new ColumnValidationResult
            {
                IsValid = missingColumns.Count == 0,
                MissingColumns = missingColumns,
                FoundHeaders = foundHeadersSet.ToList()
            };
        }
    }

    /// <summary>
    /// Result of column validation
    /// </summary>
    public class ColumnValidationResult
    {
        public bool IsValid { get; set; }
        public List<string> MissingColumns { get; set; } = new List<string>();
        public List<string> FoundHeaders { get; set; } = new List<string>();
        public string ErrorMessage => MissingColumns.Count > 0 
            ? $"Missing required columns: {string.Join(", ", MissingColumns)}" 
            : string.Empty;
    }

    /// <summary>
    /// Import configuration options
    /// </summary>
    public class ImportConfiguration
    {
        /// <summary>
        /// Maximum number of records allowed per import
        /// </summary>
        public const int MaxRecordsPerImport = 200;

        /// <summary>
        /// Maximum file size in bytes (10MB)
        /// </summary>
        public const long MaxFileSizeBytes = 10 * 1024 * 1024;

        /// <summary>
        /// Allowed file extensions
        /// </summary>
        public static readonly string[] AllowedExtensions = { ".xlsx", ".xls" };

        /// <summary>
        /// Whether to allow updates to existing records
        /// </summary>
        public bool AllowUpdates { get; set; } = true;

        /// <summary>
        /// Whether to create new suppliers if they don't exist
        /// </summary>
        public bool CreateMissingSuppliers { get; set; } = false;

        /// <summary>
        /// Whether to create new ports if they don't exist
        /// </summary>
        public bool CreateMissingPorts { get; set; } = false;

        /// <summary>
        /// Default import mode
        /// </summary>
        public string DefaultImportMode { get; set; } = "UpdateExisting";
    }
}