package com.temp.foundation.widgets.inputfieldsupport;

import java.util.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.event.shared.*;
import com.temp.foundation.widgets.support.*;
import com.temp.foundation.widgets.support.events.*;
import com.temp.shared.*;
import com.temp.shared.externalization.*;

public class InputWidgetValidator<T> implements InputWidgetValueAdapter<T>
{

    protected final NonDomHandlerManager<ChangeHandler> handlerManager;
    protected final InputWidgetValueAdapter<T> delegate;
    protected final List<ValueValidator<T>> validators = new ArrayList<ValueValidator<T>>();
    protected E13nData errorData;

    public InputWidgetValidator(InputWidgetValueAdapter<T> delegate) {
        handlerManager = new NonDomHandlerManager<ChangeHandler>(this);
        this.delegate = delegate;
        delegate.addChangeHandler(new ChangeHandler() {
            @Override
            public void onChange(ChangeEvent event) {
                validateWithErrorStateChangeNotification();
            }
        });
    }

    public InputWidgetValidator(InputWidgetValueAdapter<T> delegate, ValueValidator<T> validator1, ValueValidator<T>... additionalValidators) {
        this(delegate);
        add(validator1);
        if (additionalValidators != null) {
            for (ValueValidator<T> validator : additionalValidators) {
                add(validator);
            }
        }
        if (!validators.isEmpty()) {
            validate();
        }
    }

    protected boolean add(ValueValidator<T> validator) {
        if (validator != null) {
            validators.add(validator);
            return true;
        }
        return false;
    }

    public void addValidator(ValueValidator<T> validator) {
        if (add(validator)) {
            validateWithErrorStateChangeNotification();
        }
    }

    public void addValidators(ValueValidator<T>... additionalValidators) {
        if (additionalValidators != null) {
            boolean anyAdded = false;
            for (ValueValidator<T> validator : additionalValidators) {
                anyAdded |= add(validator);
            }
            if (anyAdded) {
                validateWithErrorStateChangeNotification();
            }
        }
    }

    /**
     * @return null if currently valid, otherwise the data to generate the Error Text
     */
    public E13nData validate() {
        T value = getValue();
        errorData = null;
        for (ValueValidator<T> validator : validators) {
            errorData = validator.checkValue(value);
            if (errorData != null) {
                break;
            }
        }
        return getErrorData();
    }

    /**
     * @return null if currently valid, otherwise the data to generate the Error Text
     */
    public E13nData getErrorData() {
        return errorData;
    }

    public HandlerRegistration addErrorStateChangeHandler(ChangeHandler handler) {
        return handler == null ? null : registerErrorStateChangeHandler(handler);
    }

    @Override
    public HandlerRegistration addChangeHandler(ChangeHandler handler) {
        return delegate.addChangeHandler(handler);
    }

    @Override
    public T getValue() {
        return delegate.getValue();
    }

    @Override
    public void setValue(T value) {
        delegate.setValue(value);
        validateWithErrorStateChangeNotification();
    }

    protected void validateWithErrorStateChangeNotification() {
        boolean hadError = (null != getErrorData());
        boolean hasError = (null != validate());
        if (hadError != hasError) {
            notifyErrorStateChangeHandlers();
        }
    }

    protected void notifyErrorStateChangeHandlers() {
        handlerManager.fireEvent(new NonDomChangeEvent());
    }

    protected HandlerRegistration registerErrorStateChangeHandler(ChangeHandler handler) {
        return handlerManager.addHandler(handler);
    }
}