using System;

using System.Collections.Generic;

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.RegularExpressions;

using System.Linq;

​

public class Program

{

    public static void Main()

    {

        var options = new JsonSerializerOptions

        {

            PropertyNameCaseInsensitive = true,

            PropertyNamingPolicy = JsonNamingPolicy.CamelCase

        };

​

        // Sample form schema in JSON with SectionId

        var formSchemaJson = @"[

        { 

            ""name"": ""buildingStreet"", 

            ""fieldValidation"": ""street"", 

            ""mandatory"": true 

        },

        { 

            ""name"": ""revenue"", 

            ""fieldValidation"": ""price"", 

            ""mandatory"": true 

        },

        {

            ""sectionId"": ""differentSection"",

            ""fields"": [

            { 

                ""name"": ""typeOfCar"", 

                ""fieldValidation"": ""cartype1"",  

                ""mandatory"": true 

            },

            {

                ""sectionId"": ""vehicleSection"",

                ""fields"": [

                { 

                    ""name"": ""typeOfCar"", 

                    ""fieldValidation"": ""cartype2"",  

                    ""mandatory"": false 

                }

                ]

            },

            {

                ""sectionId"": ""licenseSection"",

                ""fields"": [

                { 

                    ""name"": ""licensePlateNumber"", 

                    ""fieldValidation"": ""license"", 

                    ""mandatory"": false, 

                    ""conditionalMandatory"": [

                    {

                        ""type"": ""or"",

                        ""conditions"": [

                        { 

                            ""sectionId"": ""vehicleSection"", 

                            ""name"": ""typeOfCar"", 

                            ""value"": [""kia"", ""honda""], 

                            ""type"": ""equal"" 

                        },

                        { 

                            ""sectionId"": ""differentSection"", 

                            ""name"": ""typeOfCar"", 

                            ""value"": [""kia"", ""honda""], 

                            ""type"": ""equal"" 

                        }

                        ]

                    }

                    ]

                }

                ]

            }

            ]

        }

        ]";

​

        // Sample field parameter table in JSON with SectionId

        var fieldParameterTableJson = @"

        [

            { ""FieldName"": ""price"", ""MaxLength"": 10, ""ValidationRule"": ""^[0-9]+(\\\\.[0-9]{1,2})?$"", ""PlaceHolder"": ""$0.00""},

            { ""FieldName"": ""street"", ""MaxLength"": 50, ""ValidationRule"": ""^[A-Za-z0-9\\s]+$"", ""PlaceHolder"": ""Enter Street""},

            { ""FieldName"": ""license"", ""MaxLength"": 8, ""ValidationRule"": ""^[A-Z0-9]+$"", ""PlaceHolder"": ""Enter Plate Number""},

            { ""FieldName"": ""cartype1"", ""MaxLength"": 20, ""ValidationRule"": ""^[A-Za-z\\\\s]+$"", ""PlaceHolder"": ""Enter Car Type""},

            { ""FieldName"": ""cartype2"", ""MaxLength"": 20, ""ValidationRule"": ""^[A-Za-z\\\\s]+$"", ""PlaceHolder"": ""Enter Car Type""}

        ]";

​

        // Deserialize schema and field parameter table

        var formSchema = JsonSerializer.Deserialize<List<FormField>>(formSchemaJson, options);

        var fieldParameters = JsonSerializer.Deserialize<List<FieldParameter>>(fieldParameterTableJson, options);

​

        // Sample form data

        string json = @"

        {

          ""fields"": [

            {

              ""name"": ""buildingStreet"",

              ""value"": ""123 Main St""

            },

            {

              ""name"": ""revenue"",

              ""value"": ""5000""

            },

            {

              ""sectionId"": ""differentSection"",

              ""fields"": [

                {

                  ""name"": ""typeOfCar"",

                  ""value"": ""kia""

                },

                {

                    ""sectionId"": ""vehicleSection"",

                    ""fields"": [

                        {

                        ""name"": ""typeOfCar"",

                        ""value"": ""Audi""

                        }

                    ]

                },

                {

                  ""sectionId"": ""licenseSection"",

                  ""fields"": [

                    {

                      ""name"": ""licensePlateNumber"",

                      ""value"": """"

                    }

                  ]

                }

              ]

            }

          ]

        }";

​

        // Deserialize the JSON string into the C# object

        Root root = JsonSerializer.Deserialize<Root>(json, options);

​

        /* Now you can access the deserialized data

        foreach (var field in root.fields)

        {

            Console.WriteLine($"Name: {field.name}, Value: {field.value}, SectionId: {field.sectionId}");

            if (field.fields != null)

            {

                Console.WriteLine("Nested fields:");

                foreach (var nestedField in field.fields)

                {

                    Console.WriteLine($"  Name: {nestedField.name}, Value: {nestedField.value}, SectionId: {nestedField.sectionId}");

                }

            }

        }

*/

        // Validate form data

        var isValid = ValidateFormData(formSchema, fieldParameters, root.Fields, string.Empty, root.Fields);

        Console.WriteLine($"Form is valid: {isValid}");

    }

​

    private static FormField? FindSectionSchema(IEnumerable<FormField> schema, string sectionId)

    {

        foreach (var formField in schema)

        {

            if (formField.SectionId == sectionId)

            {

                return formField;

            }

​

            if (formField.Fields != null && formField.Fields.Any())

            {

                var nestedResult = FindSectionSchema(formField.Fields, sectionId);

                if (nestedResult != null)

                {

                    return nestedResult;

                }

            }

        }

​

        return null;

    }

​

    private static Field? FindFormDataSection(IEnumerable<Field> FormData, string sectionId)

    {

        foreach (Field field in FormData)

        {

            if (field.SectionId == sectionId)

            {

                return field;

            }

​

            if (field.Fields != null && field.Fields.Any())

            {

                var nestedResult = FindFormDataSection(field.Fields, sectionId);

                if (nestedResult != null)

                {

                    return nestedResult;

                }

            }

        }

        return null;

    }

​

    private static Field? FindField(IEnumerable<Field> FormData, string sectionId, string name)

    {

        //if(sectionId != string.Empty) need to cater for first layer

        Field Section = FindFormDataSection(FormData, sectionId);        

        Field Found = Section.Fields.Where(x=>x.Name == name).ToList().FirstOrDefault();

        return Found;

    }

​

​

    // Validate form data against schema and field parameters

    public static bool ValidateFormData(IEnumerable<FormField> schema, IEnumerable<FieldParameter> parameters, IEnumerable<Field> formData, string currentSection, IEnumerable<Field> allFormData)

    {

        Console.WriteLine("validate formdata start");

        bool isValid = true;

        var count = 1;

​

        foreach (Field field in formData)

        {

            Console.WriteLine(count++);

            Console.WriteLine($"current field - Name: {field.Name}, Value: {field.Value}, SectionId: {field.SectionId}");

            Console.WriteLine($"current section - {currentSection}");

​

            // If the field represents a section, update the current section and process nested fields recursively

            if (string.IsNullOrEmpty(field.Name))

            {

                currentSection = field.SectionId ?? string.Empty;

​

                if (field.Fields != null && field.Fields.Any() && !string.IsNullOrEmpty(currentSection))

                {

                    isValid = ValidateFormData(schema, parameters, field.Fields, currentSection, allFormData);

                    if (!isValid) return false;

                }

                continue;

            }

​

            // Find the corresponding schema for the current section and field

            FormField? foundSchema = null;

​

            // If no current section, search directly in the root schema

            if (string.IsNullOrEmpty(currentSection))

            {

                foundSchema = schema.FirstOrDefault(s => s.Name == field.Name);

            }

            else

            {

                // Find the schema for the current section and its nested fields

                var sectionSchema = FindSectionSchema(schema, currentSection);

                if (sectionSchema != null && sectionSchema.Fields != null)

                {

                    foundSchema = sectionSchema.Fields.FirstOrDefault(s => s.Name == field.Name);

                }

            }

​

            if (foundSchema != null)

            {

                Console.WriteLine($"current schema - Name: {foundSchema.Name}, Value: {foundSchema.FieldValidation}, SectionId: {foundSchema.SectionId}");

            }

            else

            {

                Console.WriteLine($"No schema found for field: {field.Name}");

                isValid = false; // Mark validation as failed if schema is missing

            }

​

            //now that we found the schema, carry out the validations

​

            //find FieldParameter

            FieldParameter FieldValidation = parameters.Where(parameters => parameters.FieldName == foundSchema.FieldValidation).ToList().FirstOrDefault();

            if (FieldValidation != null)

            {

                Console.WriteLine($"current validation - Name: {FieldValidation.FieldName}, Validation Regex: {FieldValidation.ValidationRule}");

            }

            else

            {

                Console.WriteLine($"No FieldValidation found for field: {field.Name}");

                isValid = false; // Mark validation as failed if schema is missing

            }

​

            bool conditionalMandatory = false;

            if (foundSchema.ConditionalMandatory != null)

            {

                Console.WriteLine($"Conditional Mandatory found {foundSchema.ConditionalMandatory}");

                foreach (var x in foundSchema.ConditionalMandatory)

                {

                    conditionalMandatory = checkConditionalMandatory(allFormData, x); 

                    if(conditionalMandatory) break;

                }

            }

​

            isValid = validateField(field, foundSchema, FieldValidation, conditionalMandatory);

        }

​

        return isValid;

    }

​

    private static bool checkConditionalMandatory(IEnumerable<Field> formData, ConditionalMandatory conditionalMandatory)

    {

        switch(conditionalMandatory.Type)

        {

            case "or":

                foreach(var condition in conditionalMandatory.Conditions)

                {

                    Field conditionField = FindField(formData, condition.SectionId, condition.Name);

                    if(checkConditionMandatoryField(conditionField, condition)) return true;

                }

                return false;

        }

        return false;

    }

​

    private static bool checkConditionMandatoryField(Field field, Conditional condition)

    {

        switch(condition.Type)

        {

            case "equal":

                foreach(var val in condition.Value)

                {

                    if(field.Value == val)

                    {

                        return true;

                    }

                }

                return false;

        }

        return false;

    }

​

    public static bool validateField(Field field, FormField schema, FieldParameter validation, bool conditionalField)

    {

        // Check mandatory fields

        if ((schema.Mandatory || conditionalField) && string.IsNullOrEmpty(field.Value))

        {

            Console.WriteLine($"Field '{field.Name}' in section '{field.SectionId}' is mandatory but missing.");

            return false;

        }

​

        // Validate field parameters

        if (validation != null && !string.IsNullOrEmpty(field.Value))

        {

            if (field.Value.Length > validation.MaxLength)

            {

                Console.WriteLine($"Field '{field.Name}' in section '{field.SectionId}' exceeds max length of {validation.MaxLength}.");

                return false;

            }

​

            if (!string.IsNullOrEmpty(validation.ValidationRule) &&

                !Regex.IsMatch(field.Value, validation.ValidationRule))

            {

                Console.WriteLine($"Field '{field.Name}' in section '{field.SectionId}' does not match the validation rule: {validation.ValidationRule}");

                return false;

            }

        }

        return true;

    }

​

​

    // Form schema classes

    public class FormField

    {

        public string Name { get; set; }

        public string FieldValidation { get; set; }

        public bool Mandatory { get; set; }

        public List<ConditionalMandatory> ConditionalMandatory { get; set; }

        public string SectionId { get; set; } = string.Empty;

        public List<FormField> Fields { get; set; }

    }

​

    public class Conditional

    {

        public string Name { get; set; }

        public List<string> Value { get; set; }

        public string SectionId { get; set; }

        public string Type { get; set; }

    }

​

    public class ConditionalMandatory

    {

        public string Type { get; set; }

        public List<Conditional> Conditions { get; set; }

    }

​

    // Field parameter table classes

    public class FieldParameter

    {

        public string FieldName { get; set; }

        public int MaxLength { get; set; }

        public string ValidationRule { get; set; }

        public string PlaceHolder { get; set; }

    }

​

    // Form Data

    public class Root

    {

        public List<Field> Fields { get; set; }

    }

​

    public class Field

    {

        public string Name { get; set; }

        public string Value { get; set; }

        public string SectionId { get; set; }

        public List<Field> Fields { get; set; }

    }

}