package com.temp.client.foundation.widget.input.fieldsupport;

import org.litesoft.core.util.externalization.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.event.shared.*;
import com.temp.client.foundation.widget.input.support.*;
import com.temp.client.foundation.widget.input.support.events.*;
import com.temp.shared.*;

import java.util.*;

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 );
    }
}