KycReference.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using Waher.Networking.XMPP.Contracts;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using NeuroAccessMaui.Services.Identity;
using NeuroAccessMaui.Services.Kyc.Models;
using NeuroAccessMaui.Services.Kyc.ViewModels;
 
namespace NeuroAccessMaui.Services.Kyc
{
    [CollectionName("KycReferences")]
    [Index(nameof(UpdatedUtc), nameof(UpdatedUtc))]
    [Index(nameof(CreatedIdentityId))]
    public class KycReference
    {
        private KycProcess? process;
        private ApplicationReview? applicationReview;
 
        [ObjectId]
        public string? ObjectId { get; set; }
 
        public string? KycXml { get; set; }
 
        public DateTime CreatedUtc { get; set; }
 
        public DateTime UpdatedUtc { get; set; }
 
        public DateTime FetchedUtc { get; set; }
 
        [DefaultValue(0)]
        public int Version { get; set; }
 
        [DefaultValueNull]
        public KycFieldValue[]? Fields { get; set; }
 
        [DefaultValueStringEmpty]
        public string FriendlyName { get; set; } = string.Empty;
 
        [DefaultValueNull]
        public string? CreatedIdentityId { get; set; }
 
        [DefaultValueNull]
        public IdentityState? CreatedIdentityState { get; set; }
 
        [DefaultValue(0.0)]
        public double Progress { get; set; }
 
        [DefaultValueNull]
        public string? LastVisitedPageId { get; set; }
 
        [DefaultValueStringEmpty]
        public string LastVisitedMode { get; set; } = "Form";
 
        [DefaultValueNull]
        public ApplicationReview? ApplicationReview
        {
            get
            {
                if (this.applicationReview is null)
                    this.TryMigrateLegacyReview();
 
                return this.applicationReview;
            }
 
            set => this.applicationReview = value;
        }
 
        [DefaultValueNull]
        [Obsolete("Use ApplicationReview instead.")]
        public string? RejectionMessage { get; set; }
 
        [DefaultValueNull]
        [Obsolete("Use ApplicationReview instead.")]
        public string? RejectionCode { get; set; }
 
        [DefaultValueNull]
        [Obsolete("Use ApplicationReview instead.")]
        public string[]? InvalidClaims { get; set; }
 
        [DefaultValueNull]
        [Obsolete("Use ApplicationReview instead.")]
        public string[]? InvalidPhotos { get; set; }
 
        [DefaultValueNull]
        [Obsolete("Use ApplicationReview instead.")]
        public KycInvalidClaim[]? InvalidClaimDetails { get; set; }
 
        [DefaultValueNull]
        [Obsolete("Use ApplicationReview instead.")]
        public KycInvalidPhoto[]? InvalidPhotoDetails { get; set; }
 
        public async Task<KycProcess?> GetProcess(string? lang = null)
        {
            if (this.process is null && this.KycXml is not null)
            {
                this.process = await KycProcessParser.LoadProcessAsync(this.KycXml, lang).ConfigureAwait(false);
 
                if (this.Fields is not null)
                {
                    foreach (KycFieldValue Field in this.Fields)
                        this.process.Values[Field.FieldId] = Field.Value;
 
                    foreach (KycPage Page in this.process.Pages)
                    {
                        foreach (ObservableKycField Field in Page.AllFields)
                            this.ApplyFieldValue(Field);
 
                        foreach (KycSection Section in Page.AllSections)
                            foreach (ObservableKycField Field in Section.AllFields)
                                this.ApplyFieldValue(Field);
                    }
                }
            }
 
            return this.process;
        }
 
        public void SetProcess(KycProcess process, string xml)
        {
            this.SetProcess(process, xml, DateTime.UtcNow, DateTime.UtcNow);
        }
 
        public void SetProcess(KycProcess process, string xml, DateTime created, DateTime updated)
        {
            this.process = process;
            this.KycXml = xml;
            this.CreatedUtc = created;
            this.UpdatedUtc = updated;
            this.FetchedUtc = DateTime.UtcNow;
            this.Fields = process.Values.Select(p => new KycFieldValue(p.Key, p.Value)).ToArray();
        }
 
        public void ApplyFieldValue(ObservableKycField Field)
        {
            if (this.process is null || !this.process.Values.TryGetValue(Field.Id, out string? Val) || Val is null)
                return;
            Field.StringValue = Val;
        }
 
        // SetFieldValue removed; logic is now in Field.StringValue
 
        public static KycReference FromProcess(KycProcess process, string xml, string? friendlyName = null)
        {
            KycReference Reference = new KycReference
            {
                process = process,
                KycXml = xml,
                CreatedUtc = DateTime.UtcNow,
                UpdatedUtc = DateTime.UtcNow,
                FetchedUtc = DateTime.UtcNow,
                Fields = process.Values.Select(P => new KycFieldValue(P.Key, P.Value)).ToArray(),
                FriendlyName = friendlyName ?? string.Empty
            };
            return Reference;
        }
 
        public async Task ApplyFieldsToProcessAsync(string? lang = null)
        {
            KycProcess? Proc = await this.GetProcess(lang).ConfigureAwait(false);
 
            if (Proc is null || this.Fields is null)
                return;
 
            foreach (KycFieldValue Field in this.Fields)
                Proc.Values[Field.FieldId] = Field.Value;
 
            foreach (KycPage Page in Proc.Pages)
            {
                foreach (ObservableKycField Field in Page.AllFields)
                    this.ApplyFieldValue(Field);
 
                foreach (KycSection Section in Page.AllSections)
                    foreach (ObservableKycField Field in Section.AllFields)
                        this.ApplyFieldValue(Field);
 
                Page.UpdateVisibilities(Proc.Values);
            }
        }
 
        public async Task<KycProcess?> ToProcess(string? lang = null)
        {
            return await this.GetProcess(lang);
        }
 
        private void TryMigrateLegacyReview()
        {
            if (this.applicationReview is not null)
                return;
 
            bool hasLegacyData =
                !string.IsNullOrWhiteSpace(this.RejectionMessage) ||
                !string.IsNullOrWhiteSpace(this.RejectionCode) ||
                (this.InvalidClaims?.Length ?? 0) > 0 ||
                (this.InvalidPhotos?.Length ?? 0) > 0 ||
                (this.InvalidClaimDetails?.Length ?? 0) > 0 ||
                (this.InvalidPhotoDetails?.Length ?? 0) > 0;
 
            if (!hasLegacyData)
                return;
 
            ApplicationReview Migrated = new ApplicationReview
            {
                Message = this.RejectionMessage ?? string.Empty,
                Code = this.RejectionCode,
                ReceivedUtc = this.UpdatedUtc
            };
 
            string[]? invalidClaims = this.InvalidClaims?
                .Where(s => !string.IsNullOrWhiteSpace(s))
                .Select(s => s.Trim())
                .ToArray();
            string[]? invalidPhotos = this.InvalidPhotos?
                .Where(s => !string.IsNullOrWhiteSpace(s))
                .Select(s => s.Trim())
                .ToArray();
 
            Migrated.InvalidClaims = invalidClaims is { Length: > 0 } ? invalidClaims : Array.Empty<string>();
            Migrated.InvalidPhotos = invalidPhotos is { Length: > 0 } ? invalidPhotos : Array.Empty<string>();
 
            ApplicationReviewClaimDetail[] claimDetails = this.InvalidClaimDetails?
                .Where(c => c is not null && !string.IsNullOrWhiteSpace(c.Claim))
                .Select(c =>
                {
                    string Claim = c.Claim.Trim();
                    string Reason = c.Reason ?? string.Empty;
                    return new ApplicationReviewClaimDetail(Claim, Reason, c.ReasonLanguage, c.ReasonCode, c.Service);
                })
                .ToArray() ?? Array.Empty<ApplicationReviewClaimDetail>();
 
            ApplicationReviewPhotoDetail[] photoDetails = this.InvalidPhotoDetails?
                .Where(p => p is not null && (!string.IsNullOrWhiteSpace(p.Mapping) || !string.IsNullOrWhiteSpace(p.FileName)))
                .Select(p =>
                {
                    string FileName = (p.FileName ?? string.Empty).Trim();
                    string DisplayName = !string.IsNullOrWhiteSpace(p.Mapping) ? p.Mapping.Trim() : FileName;
                    return new ApplicationReviewPhotoDetail(FileName, DisplayName, p.Reason ?? string.Empty, p.ReasonLanguage, p.ReasonCode, p.Service);
                })
                .ToArray() ?? Array.Empty<ApplicationReviewPhotoDetail>();
 
            Migrated.InvalidClaimDetails = claimDetails;
            Migrated.InvalidPhotoDetails = photoDetails;
 
            this.applicationReview = Migrated;
            this.RejectionMessage = null;
            this.RejectionCode = null;
            this.InvalidClaims = null;
            this.InvalidPhotos = null;
            this.InvalidClaimDetails = null;
            this.InvalidPhotoDetails = null;
        }
    }
}