using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using log4net;
using Sleis.Models;
using Sleis.Utility;
using Sleis.ViewModels;
using Spring.Validation;
using System.Text;
using Spring.Expressions;

namespace Sleis.Validation.Spring
{
    public class ListValidator : BaseSimpleValidator
    {
        public string ProviderFormat { get; set; }
        public IValidator Validator { get; set; }
        public IDictionary<string, object> ContextParams { get; set; }
        internal static ILog Log;

        
        public ListValidator()
        {
            Log = LogManager.GetLogger(this.GetType());
        }

        public override string ToString()
        {            
            return ReflectionUtility.GetPublicPropertiesString(this);
        }



        public override bool Validate(object validationContext, IDictionary contextParams, IValidationErrors errors)
        {            
            Log.DebugFormat("Validate({0},{1},{2})", validationContext, contextParams, errors);

            if (contextParams == null)
            {
                contextParams = new Dictionary<object, object>();
            }
            
            if (Validator == null)
            {
                throw new ArgumentNullException("Validator");
            }
            //add current parent context to dictionary
            var objType = validationContext.GetType();
            contextParams[String.Format("Current.{0}", objType.BaseType.Name)] = validationContext;
            Log.DebugFormat("Validating: {0}", validationContext);

            if (base.EvaluateWhen(validationContext, contextParams))
            {
                object objectToValidate = base.EvaluateTest(validationContext, contextParams);

                IEnumerable objects = objectToValidate as IEnumerable;
                IEnumerator enumerator = objects.GetEnumerator();
                int counter = 0;
                while (enumerator.MoveNext())
                {
                    object validationCandaidate = enumerator.Current;                    
                    Log.DebugFormat("Validating: {0}", validationCandaidate);

                    IValidationErrors subErrors = new ValidationErrors();

                    if (!Validator.Validate(validationCandaidate, contextParams, subErrors))
                    {
                        string innerProvider = String.Format(ProviderFormat, counter);
                        Log.DebugFormat("List Provider: {0}", innerProvider);

                        foreach (string provider in subErrors.Providers)
                        {
                            //" by using "~" in the provider context, it will not use the inner provider.
                            string itemChildProvider = "";
                            if (provider.IndexOf("~") == 0)
                            {

                                itemChildProvider = provider.Substring(1);
                            }
                            else
                            {
                                itemChildProvider = innerProvider + provider;
                            }
                            Log.DebugFormat("List Item Provider: {0}", itemChildProvider);

                            foreach (ErrorMessage error in subErrors.GetErrors(provider))
                            {
                                Log.DebugFormat("Error: {0}", error);
                                errors.AddError(itemChildProvider, error);
                            }
                        }
                    }
                    counter++;
                }
            }
            return errors.IsEmpty;
        }
        
        protected override bool Validate(object objectToValidate)
        {
            return Validate(objectToValidate, null, new ValidationErrors());
        }
    }
}