var LifecycleState = {};
LifecycleState.ALERT     = "alert";
LifecycleState.MESSAGE     = "message";
LifecycleState.AUTO     = "auto";
LifecycleState.BOTH       = "both";
LifecycleState.NONE     = "none";

var LifecycleEvent = {};
LifecycleEvent.ONSUBMIT    = 0x01;
LifecycleEvent.ONINPUT    = 0x02;
LifecycleEvent.ONCHANGE    = 0x03;
LifecycleEvent.ONRESTRICT  = 0x04;

var Severity = {};
Severity.SEVERITY_WARN    = "warn";
Severity.SEVERITY_ERROR    = "error";
Severity.SEVERITY_INFO    = "info";

function Map() {}

Map.Entry = function(key, value)
{
    this.key = key;
    this.value = value;
}

Map.Entry.prototype.getKey = function()
{
    return this.key;
}

Map.Entry.prototype.getValue = function()
{
    return this.value;
}

function HashMap()
{
    this.list = [];
    this.table = [];
}

HashMap.prototype.put = function(key, value)
{
    this[key] = value;

    var entry = new Map.Entry(key, value);
    this.list.push(entry);
    this.table[key] = entry;
}

HashMap.prototype.get = function(key)
{
    return this[key];
}

HashMap.prototype.contains = function(key)
{
    return (this.table[key] instanceof Map.Entry);
}

HashMap.prototype.keys = function()
{
    var keys = [];
    for (var i = 0; i < this.list.length; i++)
    {
        keys.push(this.list[i].getKey());
    }

    return keys;
}

HashMap.prototype.values = function()
{
    var values = [];
    for (var i = 0; i < this.list.length; i++)
    {
        values.push(this.list[i].getValue());
    }

    return values;
}

HashMap.prototype.entrySet = function()
{
    return this.list;
}

String.getAsString = function(value)
{
    // Handle Strings
    if (typeof value === "string")
    {
        return value;
    }

    // Handle Numbers
    else if (typeof value === "number")
    {
        return "" + value + "";
    }

    // Handle Booleans
    else if (typeof value === "boolean")
    {
        return (value ? "true" : "false");
    }

    // Handle Objects
    else if (typeof value === "object" && typeof value.toString === "function")
    {
        return value.toString();
    }

    // Invalid Data Type
    else { return null; }
};

String.prototype.trim = function()
{
    return this.replace(/^\s+|\s+$/g, "");
};

String.prototype.ltrim = function()
{
    return this.replace(/^\s+/, "");
};

String.prototype.rtrim = function()
{
    return this.replace(/\s+$/, "");
};

String.prototype.compareTo = function(value)
{
    return this.localeCompare(value);
};

function StringBuffer() {
    this.buffer = [];
}

StringBuffer.prototype.add = function (str) {
    this.buffer.push(str);
    return this;
};

StringBuffer.prototype.toString = function () {
    return this.buffer.join("");
};

function FacesMessage(summary, detail, severity)
{
    // Save Properties
    this.summary = summary;
    this.detail = detail;
    this.severity = (severity || Severity.SEVERITY_ERROR);
}

function ComponentMessage(component, object, message, state)
{
    this.component = component;
    this.object = object;
    this.message = message;
    this.state = state;
}

function ValidatorException(message)
{
    // Save Values
    this.message = message;
}

function ConverterException(message)
{
    this.message = message;
}

function ErrorHandler() {}
ErrorHandler.prototype.addError = function(error) {};
ErrorHandler.prototype.clearErrors = function() {};
ErrorHandler.prototype.showErrors = function() {};

function AlertHandler()
{
    this.errors = [];
}

AlertHandler.prototype.addError = function(error)
{
    var valid = false;
    var state = error.state;

    // Alert or Both (Alert & Message) Always Valid
    if (!state ||
        state === LifecycleState.ALERT || state === LifecycleState.BOTH)
    {
        valid = true;
    }

    // Auto Only Valid if No Messenger
    else if (state === LifecycleState.AUTO)
    {
        var messenger = error.component.getMessenger();
        if (messenger === null)
        {
            valid = true;
        }
    }

    // Add if Valid
    if (valid === true)
    {
        this.errors.push(error);
    }
};

AlertHandler.prototype.clearErrors = function()
{
    this.errors = [];
};

AlertHandler.prototype.showErrors = function()
{
    // Verify Errors Exist
    if (this.errors.length === 0)
    {
        return;
    }

    // Construct Message
    var message = "Please correct the following problem" +
                    (this.errors.length > 1 ? "s" : "") + " and try again:\n";

    // Add Errors
    for (var i = 0; i < this.errors.length; i++)
    {
        // Get Message
        var fmessage = this.errors[i].message;

        // Create Message
        var errMessage = (fmessage ? fmessage.summary : "");
        if (fmessage && fmessage.detail && fmessage.detail.length > 0)
        {
            errMessage += " " + fmessage.detail;
        }

        // Add to Message
        message += "\n- " + errMessage;
    }

    // Alert Message
    window.alert(message);

    if (this.errors[0] && this.errors[0].component &&
        this.errors[0].focus && typeof this.errors[0].focus === "function")
    {
        this.errors[0].component.focus();
    }
};

function MessageHandler()
{
    this.errors = [];
}

MessageHandler.prototype.addError = function(error)
{
    var valid = false;
    var state = error.state;

    // Message or Both (Alert & Message) Always Valid
    if (!state ||
        state === LifecycleState.MESSAGE || state === LifecycleState.BOTH)
    {
        valid = true;
    }

    // Auto Only Valid if No Messenger
    else if (state === LifecycleState.AUTO)
    {
        var messenger = error.component.getMessenger();
        if (messenger !== null)
        {
            valid = true;
        }
    }

    // Add if Valid
    if (valid === true)
    {
        this.errors.push(error);
    }
};

MessageHandler.prototype.clearErrors = function()
{
    this.errors = [];
};

MessageHandler.prototype.showErrors = function()
{
    for (var i = 0; i < this.errors.length; i++)
    {
        // Get Messenger Component and Display Error
        var messenger = this.errors[i].component.getMessenger();
        if (messenger !== null)
        {
            messenger.showError(this.errors[i]);
        }
    }
};

function GlobalMessageHandler()
{
    this.errors = [];
}

GlobalMessageHandler.prototype.addError = function(error)
{
    var valid = false;
    var state = error.state;

    // Message or Both (Alert & Message) Always Valid
    if (!state ||
        state === LifecycleState.MESSAGE || state === LifecycleState.BOTH)
    {
        valid = true;
    }

    // Auto Only Valid if No Messenger
    else if (state === LifecycleState.AUTO)
    {
        var messenger = Lifecycle.getMessenger();
        if (messenger !== null)
        {
            valid = true;
        }
    }

    // Add if Valid
    if (valid === true)
    {
        this.errors.push(error);
    }
};

GlobalMessageHandler.prototype.clearErrors = function()
{
    this.errors = [];
};

GlobalMessageHandler.prototype.showErrors = function()
{
    // Get Messenger and Show Errors
    var messenger = Lifecycle.getMessenger();
    if (messenger !== null)
    {
        messenger.showErrors(this.errors);
    }
};

function StyleHandler()
{
    this.errors = [];
}

StyleHandler.prototype.addError = function(error)
{
    this.errors.push(error);
};

StyleHandler.prototype.clearErrors = function()
{
    this.errors = [];
};

StyleHandler.prototype.showErrors = function()
{
    for (var i = 0; i < this.errors.length; i++)
    {
        // Get Message and Severity
        var message = this.errors[i].message;
        var severity = (message ? message.severity : null);
        if (!severity)
        {
            severity = Severity.SEVERITY_ERROR;
        }

        // Get Style Class as Error or Warning
        var styleClass = null;
        if (severity === Severity.SEVERITY_ERROR)
        {
            styleClass = this.errors[i].object.errorClass;
        }
        else if (severity === Severity.SEVERITY_WARN)
        {
            styleClass = this.errors[i].object.warningClass;
        }

        // Set Style Class
        if (styleClass)
        {
            this.errors[i].component.setStyleClass(styleClass);
        }
    }
};

function ClientForm(formId)
{
    // Setup Properties
    this.components = new HashMap();

    // Setup Events
    var form = document.getElementById(formId);
    if (!form)
    {
        form = document.forms[formId];
    }

    if (form)
    {
        // Save Current Event
        form.onsubmitnext = form.onsubmit;
        form.onsubmit = function()
        {
            // Call Initial Event
            if (this.onsubmitnext && typeof this.onsubmitnext === "function")
            {
                var status = this.onsubmitnext();
                if (!status) { return false; }
            }

            // Validate this Form
            return Lifecycle.validateForm(this);
        };
    }

    // Save Form
    this.form = form;
}

ClientForm.prototype.getFields = function()
{
    return this.form.elements;
}

ClientForm.prototype.findComponent = function(clientId)
{
    return this.components.get(clientId);
};

ClientForm.prototype.getComponents = function()
{
    return this.components.values();
};

ClientForm.prototype.getComponent = function(clientId, autoCreate)
{
    // Validate Parameters
    if (!clientId)
    {
        return null;
    }

    // Setup Default Values
    autoCreate = (autoCreate || false);

    // Get Associated Component
    var component = this.components.get(clientId);

    // Create Component if Auto Create
    if (!component && autoCreate)
    {
        component = new ClientComponent(clientId);
        component.setForm(this);
        this.components.put(clientId, component);
    }

    // Return Component
    return component;
};

function ClientComponent(clientId)
{
    // Save Properties
    this.clientId = clientId;

    // Initialize Properties
    this.form = null;
    this.valid = true;
    this.renderer = null;
    this.converter = null;
    this.validators = [];
    this.messenger = null;
    this.restrictInput = false;
    this.restrictPattern = null;
    this.addedStyleClasses = null;
}

ClientComponent.prototype.isValid = function()
{
    return this.valid;
};

ClientComponent.prototype.setValid = function(valid)
{
    this.valid = valid;
};

ClientComponent.prototype.getValue = function()
{
    return this.getConvertedValue();
};

ClientComponent.prototype.setValue = function(value)
{
    // Get Context
    var context = FacesContext.getCurrentInstance();

    // Set Value via Renderer
    var renderer = this.getRenderer();
    if (renderer !== null)
    {
        try
        {
            renderer.setConvertedValue(context, this, value);
        }
        catch (exception)
        {
            // nothing to do
        }
    }

}

ClientComponent.prototype.getClientId = function()
{
    return this.clientId;
};

ClientComponent.prototype.getForm = function()
{
    return this.form;
}

ClientComponent.prototype.setForm = function(form)
{
    this.form = form;
}

ClientComponent.prototype.getField = function()
{
    var field = document.getElementById(this.clientId);
    if (!field)
    {
        var fields = this.getForm().getFields();
        field = fields[this.clientId];
    }

    return field;
}

ClientComponent.prototype.getSubmittedValue = function()
{
    // Decode the component per renderer
    // Renderer will set the submitted value
    var renderer = this.getRenderer();
    if (renderer !== null)
    {
        var context = FacesContext.getCurrentInstance();
        renderer.decode(context, this);
    }
    else
    {
        this.setValid(false);
    }

    // Return Submitted Value
    return this.submittedValue;
};

ClientComponent.prototype.setSubmittedValue = function(value)
{
    if (typeof value === "string")
    {
        value = value.trim();
    }

    this.submittedValue = value;
};

ClientComponent.prototype.getConvertedValue = function()
{
    try
    {
        // Get Submitted Value
        var value = this.getSubmittedValue();

        // Get Context
        var context = FacesContext.getCurrentInstance();

        // Convert Value from Renderer
        var renderer = this.getRenderer();
        if (renderer !== null)
        {
            return renderer.getConvertedValue(context, this, value);
        }

        // Convert Value if Available
        var converter = this.getConverter();
        if (converter !== null)
        {
            return converter.getAsObject(context, this, value);
        }
    }
    catch (exception)
    {
        this.setValid(false);
        throw exception;
    }

    // Return Value
    return null;
};

ClientComponent.prototype.focus = function()
{
    // Get Associated Renderer
    var renderer = this.getRenderer();
    if (renderer !== null)
    {
        // Set Focus on Renderer
        renderer.focus(this);
    }
};

ClientComponent.prototype.setDisabled = function(disabled)
{
    // Get Associated Renderer
    var renderer = this.getRenderer();
    if (renderer !== null)
    {
        renderer.setDisabled(this, disabled);
    }
};

ClientComponent.prototype.clearStyleClass = function()
{
    // Get Associated Renderer
    var renderer = this.getRenderer();
    if (renderer !== null && this.addedStyleClasses !== null)
    {
        for (var i = 0; i < this.addedStyleClasses.length; i++)
        {
            renderer.removeStyleClass(this, this.addedStyleClasses[i]);
        }

        this.addedStyleClasses = null;
    }
};

ClientComponent.prototype.setStyleClass = function(styleClass)
{
    // Get Associated Renderer
    var renderer = this.getRenderer();
    if (renderer !== null)
    {
        if (this.addedStyleClasses === null)
        {
            this.addedStyleClasses = [];
        }

        this.addedStyleClasses.push(styleClass);
        renderer.addStyleClass(this, styleClass);
    }
};

ClientComponent.prototype.setInitialStyleClass = function(initialStyleClass)
{
    if (this.initialStyleClass !== null)
    {
        this.initialStyleClass = initialStyleClass;
    }
};

ClientComponent.prototype.getMessenger = function()
{
    return this.messenger;
};

ClientComponent.prototype.setMessenger = function(messenger)
{
    this.messenger = messenger;
};

ClientComponent.prototype.isRestrictInput = function()
{
    return this.restrictInput;
};

ClientComponent.prototype.setRestrictInput = function(restrictInput)
{
    this.restrictInput = restrictInput;
};

ClientComponent.prototype.getRestrictPattern = function()
{
    return this.restrictPattern;
};

ClientComponent.prototype.setRestrictPattern = function(restrictPattern)
{
    this.restrictPattern = restrictPattern;
};

ClientComponent.prototype.getRenderer = function()
{
    // Create Default Renderer if None Set
    if (this.renderer === null)
    {
        // Get Field
        var field = this.getField();
        if (!field)
        {
            return null;
        }

        // Return Default Renderer
        this.renderer = new DefaultClientRenderer();
    }

    // Return Renderer
    return this.renderer;
};

ClientComponent.prototype.setRenderer = function(renderer)
{
    this.renderer = renderer;
};

ClientComponent.prototype.getConverter = function()
{
    return this.converter;
};

ClientComponent.prototype.setConverter = function(converter)
{
    // Save Converter
    this.converter = converter;
};

ClientComponent.prototype.clearValidators = function()
{
    this.validators = [];
};

ClientComponent.prototype.getValidators = function()
{
    return this.validators;
};

ClientComponent.prototype.addValidator = function(validator)
{
    // Save Validator
    this.validators.push(validator);
};

ClientComponent.prototype.initialize = function()
{
    // Get Associated Renderer
    var renderer = this.getRenderer();
    if (renderer === null) { return; }

    // Apply Style Class if Set
    if (this.initialStyleClass !== null)
    {
        this.setStyleClass(this.initialStyleClass);
        this.initialStyleClass = null;
    }

    // Apply Restriction Events
    if (this.isRestrictInput())
    {
        // Create Event Function
        function ValidateInputCallback(component)
        {
            var _component = component;
            this.callback = function(field, evt)
            {
                return Lifecycle.validateInput(_component, evt);
            };
        }

        // Add Event to Renderer
        renderer.addEventListener(this, "onkeypress",
            new ValidateInputCallback(this).callback);
    }

    // Event States (only add once)
    var oninputState = false;
    var onchangeState = false;

    // Setup Events per Validator
    for (var i = 0; i < this.validators.length; i++)
    {
        // Get Validator
        var validator = this.validators[i];

        // Create Event Function
        function ValidateFieldCallback(component, type)
        {
            var _component = component;
            var _type = type;
            this.callback = function(field, evt)
            {
                return Lifecycle.validateField(_component, evt, _type);
            };
        }

        // Apply Key Press Events
        if (!oninputState && validator.isValidateOnInput())
        {
            // Add Event to Renderer
            renderer.addEventListener(this, "onkeyup",
                new ValidateFieldCallback(this, LifecycleEvent.ONINPUT).callback);

            // Save State
            oninputState = true;
        }

        // Apply On Change Events
        if (!onchangeState && validator.isValidateOnChange())
        {
            // Add Event to Renderer
            renderer.addEventListener(this, "onchange",
                new ValidateFieldCallback(this, LifecycleEvent.ONCHANGE).callback);

            // Save State
            onchangeState = true;
        }
    }
};

ClientComponent.prototype.convert = function(context)
{
    // Get Converted Value
    return this.getConvertedValue();
};

ClientComponent.prototype.validate = function(context, eventType)
{
    // Clear Errors/Styles
    this.clearStyleClass();

    // Clear Messenger Error
    var messenger = this.getMessenger();
    if (messenger !== null)
    {
        messenger.clearError();
    }

    // Convert the Value
    var value = null;
    try
    {
        value = this.convert(context);
    }
    catch (exception)
    {
        this.setValid(false);
        return false;
    }

    if (!this.isValid())
    {
        return false;
    }

    // Validate Each Validator
    var status = true;
    var validators = this.getValidators();
    for (var i = 0; i < validators.length; i++)
    {
        // Call Validator
        try
        {
            if (!validators[i].validate(context, this, value, eventType))
            {
                status = false;
            }
        }
        catch (exception)
        {
            this.setValid(false);
        }
    }

    // Valid
    this.setValid(true);

    // Return Status
    return status;
};

ClientComponent.prototype.checkInput = function(context, value)
{
    // Check if Restrict Input
    if (this.isRestrictInput())
    {
        // Check if Pattern
        var restrictPattern = this.getRestrictPattern();
        if (restrictPattern === null)
        {
            try
            {
                // Check Input
                var converter = this.converter;
                if (converter !== null)
                {
                    return converter.checkInput(context, this, value);
                }
            }
            catch (exception)
            {
                // Failed Conversion, so Restrict
                return false;
            }
        }
        else
        {
            var regexp = new RegExp(restrictPattern);
            if (!regexp.test(value))
            {
                // Failed, so Restrict
                return false;
            }
        }
    }

    // Success
    return true;
};


function ClientRenderer() {}
ClientRenderer.prototype.decode = function(context, component) {};
ClientRenderer.prototype.getConvertedValue = function(context, component,
                                                      submittedValue)
{
    // No conversion necessary
    return submittedValue;
};

ClientRenderer.prototype.setConvertedValue = function(context, component, value)
{
    // nothing to do by default
}

ClientRenderer.prototype.focus = function(component) {};
ClientRenderer.prototype.setDisabled = function(component, disabled) {};
ClientRenderer.prototype.addStyleClass = function(component, styleClass) {};
ClientRenderer.prototype.removeStyleClass = function(component, styleClass) {};
ClientRenderer.prototype.addEventListener = function(component, event, func) {};

function AbstractClientRenderer() {}
AbstractClientRenderer.prototype = new ClientRenderer();

AbstractClientRenderer.prototype.getConvertedValue = function(context,
                                                              component,
                                                              submittedValue)
{
    // Get Converter
    var converter = component.getConverter();
    if (converter !== null)
    {
        return converter.getAsObject(context, component, submittedValue);
    }

    // Return Submitted Value by Default
    return submittedValue;
};

AbstractClientRenderer.prototype.setConvertedValue = function(context,
                                                              component,
                                                              value)
{
    // Get Converter
    var stringValue = null;
    var converter = component.getConverter();
    if (converter !== null)
    {
        stringValue = converter.getAsString(context, component, value);
    }
    else
    {
        stringValue = value.toString();
    }

    // Update Request Parameters/Field
    var clientId = component.getClientId();
    context.getRequestParameterMap().set(clientId, stringValue);
};

AbstractClientRenderer.prototype.getFields = function(component)
{
    var field = component.getField();
    if (!field)
    {
        return [];
    }

    return (field.tagName == "SELECT" || !field.length ? [ field ] : field);
};

AbstractClientRenderer.prototype.focus = function(component)
{
    // Get Renderer Fields
    var fields = this.getFields(component);
    if (!fields || !fields.length)
    {
        return;
    }

    // Focus Initial Field
    if (fields[0].focus && typeof fields[0].focus === "function")
    {
        fields[0].focus();
    }
};

AbstractClientRenderer.prototype.setDisabled = function(component, disabled)
{
    // Get Renderer Fields
    var fields = this.getFields(component);
    if (!fields || !fields.length)
    {
        return;
    }

    // Update Disabled State
    for (var i = 0; i < fields.length; i++)
    {
        this.disable(component, disabled, fields[i]);
    }
}

AbstractClientRenderer.prototype.disable = function(component, disabled, field)
{
    // Mark Disabled State
    field.disabled = disabled;

    // Update Children
    var children = field.childNodes;
    for (var i = 0; i < children.length; i++)
    {
        this.disable(component, disabled, children[i]);
    }
}

AbstractClientRenderer.prototype.addStyleClass = function(component, styleClass)
{
    // Get Renderer Fields
    var fields = this.getFields(component);
    if (!fields || !fields.length)
    {
        return;
    }

    // Add Style Class
    for (var i = 0; i < fields.length; i++)
    {
        if (fields[i].className == null)
        {
            fields[i].className = "";
        }
        fields[i].className += " " + styleClass;
    }
};

AbstractClientRenderer.prototype.removeStyleClass = function(component,
                                                             styleClass)
{
    // Get Renderer Fields
    var fields = this.getFields(component);
    if (!fields || !fields.length)
    {
        return;
    }

    // Remove Style Class
    for (var i = 0; i < fields.length; i++)
    {
        var classNames = "";
        var styleClasses =
            (fields[i].className != null ? fields[i].className.split(' ') : "");
        for (var j = 0; j < styleClasses.length; j++)
        {
            if (styleClasses[j] !== styleClass)
            {
                classNames += " " + styleClasses[j];
            }
        }

        fields[i].className = classNames;
    }
};

AbstractClientRenderer.prototype.addEventListener = function(component, name,
                                                             func)
{
    // Get Renderer Fields
    var fields = this.getFields(component);
    if (!fields || !fields.length)
    {
        return;
    }

    // Add the Event to Each Field
    for (var i = 0; i < fields.length; i++)
    {
        // Ignore Invalid Fields
        if (!fields[i]) { continue; }

        // Create Backup List
        if (!fields[i].nextevent)
        {
            fields[i].nextevent = [];
        }
        if (!fields[i].currentevent)
        {
            fields[i].currentevent = [];
        }

        // Assign Event
        fields[i].currentevent[name] = func;
        fields[i].nextevent[name] = fields[i][name];
        fields[i][name] = function(evt)
        {
            evt = (evt || window.event);
            if (this.nextevent[name] &&
                typeof this.nextevent[name] === "function")
            {
                var status = this.nextevent[name](this, evt);
                if (!status) { return false; }
            }

            return this.currentevent[name](this, evt);
        };
    }
};

function DefaultClientRenderer() {}
DefaultClientRenderer.prototype = new AbstractClientRenderer();

DefaultClientRenderer.prototype.decode = function(context, component)
{
    var clientId = component.getClientId();
    var params = context.getRequestParameterMap();
    var value = params.get(clientId);
    if (value == null)
    {
        component.setValid(false);
        return null;
    }
    else
    {
        component.setSubmittedValue(params.get(clientId));
    }
};

function ClientMessage(clientId)
{
    // Save Properties
    this.clientId = clientId;

    // Setup Properties
    this.showSummary = true;
    this.showDetail = false;
    this.errorClass = null;
    this.errorStyle = null;
    this.warnClass = null;
    this.warnStyle = null;
}

ClientMessage.prototype.clearError = function()
{
    // Get the Associated Field
    var field = this.getField();
    if (!field) { return; }

    // Hide Field and Reset Message
    field.style.display = 'none';
    field.innerHTML = '';
};

ClientMessage.prototype.showError = function(error)
{
    // Get the Associated Field
    var field = this.getField();
    if (!field) { return; }

    // Check How to Display Message
    var summary = null;
    if (error.message && error.message.summary)
    {
        summary = error.message.summary;
    }

    var detail = null;
    if (error.message && error.message.detail)
    {
        detail = error.message.detail;
    }

    var showSummary = (this.isShowSummary() && summary);
    var showDetail = (this.isShowDetail() && detail);

    // Create Message
    var message = "";
    if (showSummary)
    {
        message = summary;
        if (showDetail)
        {
            message += " ";
        }
    }

    if (showDetail)
    {
        message += detail;
    }

    // Create Span for Message
    var severity = (error.message ? error.message.severity : null);
    if (severity === null)
    {
        severity = Severity.SEVERITY_ERROR;
    }

    var style = this.getSeverityStyle(severity);
    var styleClass = this.getSeverityStyleClass(severity);

    var span = '<span';
    if (style !== null)
    {
        span += ' style="' + style + '"';
    }
    if (styleClass !== null)
    {
        span += ' class="' + styleClass + '"';
    }
    span += '>';

    // Display Field and Show Message
    field.innerHTML = span + message + '</span>';
    field.style.display = 'inline';
};

ClientMessage.prototype.getSeverityStyleClass = function(severity)
{
    if (severity === Severity.SEVERITY_ERROR)
    {
        return this.errorClass;
    }
    else if (severity === Severity.SEVERITY_WARN)
    {
        return this.warnClass;
    }
    else
    {
        return null;
    }
};

ClientMessage.prototype.getSeverityStyle = function(severity)
{
    if (severity === Severity.SEVERITY_ERROR)
    {
        return this.errorStyle;
    }
    else if (severity === Severity.SEVERITY_WARN)
    {
        return this.warnStyle;
    }
    else
    {
        return null;
    }
};

ClientMessage.prototype.getField = function()
{
    return document.getElementById(this.clientId);
};

ClientMessage.prototype.isShowSummary = function()
{
    return this.showSummary;
};

ClientMessage.prototype.setShowSummary = function(showSummary)
{
    this.showSummary = showSummary;
};

ClientMessage.prototype.isShowDetail = function()
{
    return this.showDetail;
};

ClientMessage.prototype.setShowDetail = function(showDetail)
{
    this.showDetail = showDetail;
};

ClientMessage.prototype.setErrorClass = function(errorClass)
{
    this.errorClass = errorClass;
};

ClientMessage.prototype.setErrorStyle = function(errorStyle)
{
    this.errorStyle = errorStyle;
};

ClientMessage.prototype.setWarnClass = function(warnClass)
{
    this.warnClass = warnClass;
};

ClientMessage.prototype.setWarnStyle = function(warnStyle)
{
    this.warnStyle = warnStyle;
};

function ClientMessages(clientId)
{
    // Save Properties
    this.clientId = clientId;

    // Setup Properties
    this.layout = "list";
    this.showSummary = true;
    this.showDetail = false;
    this.errorClass = null;
    this.errorStyle = null;
    this.warnClass = null;
    this.warnStyle = null;
}

ClientMessages.prototype.clearError = function()
{
    // Get the Associated Field
    var field = this.getField();
    if (!field) { return; }

    // Hide Field and Reset Message
    field.style.display = 'none';
    field.innerHTML = '';
};

ClientMessages.prototype.showErrors = function(errors)
{
    // Get the Associated Field
    var field = this.getField();
    if (!field) { return; }

    // Create Message
    var messages = "";
    var layout = this.getLayout();
    if (layout === "list")
    {
        messages = this.getMessagesAsList(errors);
    }
    else if (layout === "table")
    {
        messages = this.getMessagesAsTable(errors);
    }

    // Display Field and Show Message
    field.innerHTML = messages;
    field.style.display = 'block';
};

ClientMessages.prototype.getSingleMessage = function(error)
{
    // Check How to Display Message
    var summary = null;
    if (error.message && error.message.summary)
    {
        summary = error.message.summary;
    }

    var detail = null;
    if (error.message && error.message.detail)
    {
        detail = error.message.detail;
    }

    var showSummary = (this.isShowSummary() && summary);
    var showDetail = (this.isShowDetail() && detail);

    // Create Message
    var message = "";
    if (showSummary)
    {
        message = summary;
        if (showDetail)
        {
            message += " ";
        }
    }

    if (showDetail)
    {
        message += detail;
    }

    return message;
};

ClientMessages.prototype.getMessagesAsList = function(errors)
{
    // Create Message
    var messages = '<ul>';
    for (var i = 0; i < errors.length; i++)
    {
        // Get Message
        var message = this.getSingleMessage(errors[i]);

        // Create Span for Message
        var severity = (errors[i].message ? errors[i].message.severity : null);
        if (severity === null)
        {
            severity = Severity.SEVERITY_ERROR;
        }

        var style = this.getSeverityStyle(severity);
        var styleClass = this.getSeverityStyleClass(severity);

        var span = '<span';
        if (style !== null)
        {
            span += ' style="' + style + '"';
        }
        if (styleClass !== null)
        {
            span += ' class="' + styleClass + '"';
        }
        span += '>';

        // Include in List
        messages += '<li>' + span + message + '</span>' + '</li>';
    }

    // Close Messages
    messages += '</ul>';

    // Return Messages
    return messages;
};

ClientMessages.prototype.getMessagesAsTable = function(errors)
{
    // Create Message
    var messages = '<table><tbody>';
    for (var i = 0; i < errors.length; i++)
    {
        // Get Message
        var message = this.getSingleMessage(errors[i]);

        // Create Span for Message
        var severity = (errors[i].message ? errors[i].message.severity : null);
        if (severity === null)
        {
            severity = Severity.SEVERITY_ERROR;
        }

        var style = this.getSeverityStyle(severity);
        var styleClass = this.getSeverityStyleClass(severity);

        var span = '<span';
        if (style !== null)
        {
            span += ' style="' + style + '"';
        }
        if (styleClass !== null)
        {
            span += ' class="' + styleClass + '"';
        }
        span += '>';

        messages += '<tr><td>' + span + message + '</span>' + '</td></tr>';
    }

    // Close Messages
    messages += '</tbody></table>';

    // Return Messages
    return messages;
};

ClientMessages.prototype.getSeverityStyleClass = function(severity)
{
    if (severity === Severity.SEVERITY_ERROR)
    {
        return this.errorClass;
    }
    else if (severity === Severity.SEVERITY_WARN)
    {
        return this.warnClass;
    }
    else
    {
        return null;
    }
};

ClientMessages.prototype.getSeverityStyle = function(severity)
{
    if (severity === Severity.SEVERITY_ERROR)
    {
        return this.errorStyle;
    }
    else if (severity === Severity.SEVERITY_WARN)
    {
        return this.warnStyle;
    }
    else
    {
        return null;
    }
};

ClientMessages.prototype.getField = function()
{
    return document.getElementById(this.clientId);
};

ClientMessages.prototype.getLayout = function()
{
    return this.layout;
};

ClientMessages.prototype.setLayout = function(layout)
{
    this.layout = layout;
};

ClientMessages.prototype.isShowSummary = function()
{
    return this.showSummary;
};

ClientMessages.prototype.setShowSummary = function(showSummary)
{
    this.showSummary = showSummary;
};

ClientMessages.prototype.isShowDetail = function()
{
    return this.showDetail;
};

ClientMessages.prototype.setShowDetail = function(showDetail)
{
    this.showDetail = showDetail;
};

ClientMessages.prototype.setErrorClass = function(errorClass)
{
    this.errorClass = errorClass;
};

ClientMessages.prototype.setErrorStyle = function(errorStyle)
{
    this.errorStyle = errorStyle;
};

ClientMessages.prototype.setWarnClass = function(warnClass)
{
    this.warnClass = warnClass;
};

ClientMessages.prototype.setWarnStyle = function(warnStyle)
{
    this.warnStyle = warnStyle;
};

function ClientConverter(converter)
{
    // Save Properties
    this.converter = converter;

    // Setup Properties
    this.errorMessage = null;
    this.errorDetail = null;
    this.errorClass = null;
    this.warningClass = null;
}

ClientConverter.prototype.setErrorMessage = function(errorMessage)
{
    this.errorMessage = errorMessage;
};

ClientConverter.prototype.setErrorDetail = function(errorDetail)
{
    this.errorDetail = errorDetail;
};

ClientConverter.prototype.setErrorClass = function(errorClass)
{
    this.errorClass = errorClass;
};

ClientConverter.prototype.setWarningClass = function(warningClass)
{
    this.warningClass = warningClass;
};

ClientConverter.prototype.getAsObject = function(context, component, value)
{
    try
    {
        // Convert if Valid
        if (this.converter !== null)
        {
            return this.converter.getAsObject(context, component, value);
        }
    }
    catch (exception)
    {
        // Get Message
        var summary = this.errorMessage;
        if (summary === null)
        {
            summary = (exception.message ? exception.message.summary : null);
        }

        var detail = this.errorDetail;
        if (detail === null)
        {
            detail = (exception.message ? exception.message.detail : null);
        }

        // Update Message
        var message = (exception.message || new FacesMessage());
        message.summary = summary;
        message.detail = detail;

        // Create Error
        var error =
            new ComponentMessage(component, this, message, LifecycleState.AUTO);

        // Add to Framework
        context.addError(error);

        // Return Failure
        return null;
    }

    // Success (w/o conversion)
    return null;
};

ClientConverter.prototype.getAsString = function(context, component, value)
{
    try
    {
        // Convert if Valid
        if (this.converter !== null)
        {
            return this.converter.getAsString(context, component, value);
        }
    }
    catch (exception)
    {
        // Get Message
        var summary = this.errorMessage;
        if (summary === null)
        {
            summary = (exception.message ? exception.message.summary : null);
        }

        var detail = this.errorDetail;
        if (detail === null)
        {
            detail = (exception.message ? exception.message.detail : null);
        }

        // Update Message
        var message = (exception.message || new FacesMessage());
        message.summary = summary;
        message.detail = detail;

        // Create Error
        var error =
            new ComponentMessage(component, this, message, LifecycleState.AUTO);

        // Add to Framework
        context.addError(error);

        // Return Failure
        return null;
    }

    // Success (w/o conversion)
    return null;
};

ClientConverter.prototype.checkInput = function(context, component, value)
{
    try
    {
        // Check Input
        var converter = this.converter;
        if (converter !== null && typeof converter.checkInput === "function")
        {
            return converter.checkInput(context, component, value);
        }
    }
    catch (exception)
    {
        // Failed Conversion, so Restrict
        return false;
    }

    // Success
    return true;
};

function ClientValidator(validator)
{
    // Save Properties
    this.validator = validator;

    // Setup Properties
    this.errorMessage = null;
    this.errorDetail = null;
    this.validateOnInput = LifecycleState.NONE;
    this.validateOnChange = LifecycleState.NONE;
    this.validateOnSubmit = LifecycleState.AUTO;
    this.errorClass = null;
    this.warningClass = null;
    this.dependencies = null;
}

ClientValidator.prototype.setErrorMessage = function(errorMessage)
{
    this.errorMessage = errorMessage;
};

ClientValidator.prototype.setErrorDetail = function(errorDetail)
{
    this.errorDetail = errorDetail;
};

ClientValidator.prototype.isValidateOnInput = function()
{
    // Verify Anything Other Than None
    return (this.validateOnInput !== LifecycleState.NONE);
};

ClientValidator.prototype.getValidateOnInput = function()
{
    return this.validateOnInput;
};

ClientValidator.prototype.setValidateOnInput = function(validateOnInput)
{
    this.validateOnInput = validateOnInput;
};

ClientValidator.prototype.isValidateOnChange = function()
{
    // Verify Anything Other Than None
    return (this.validateOnChange !== LifecycleState.NONE);
};

ClientValidator.prototype.getValidateOnChange = function()
{
    return this.validateOnChange;
};

ClientValidator.prototype.setValidateOnChange = function(validateOnChange)
{
    this.validateOnChange = validateOnChange;
};

ClientValidator.prototype.isValidateOnSubmit = function()
{
    // Verify Anything Other Than None
    return (this.validateOnSubmit !== LifecycleState.NONE);
};

ClientValidator.prototype.getValidateOnSubmit = function()
{
    return this.validateOnSubmit;
};

ClientValidator.prototype.setValidateOnSubmit = function(validateOnSubmit)
{
    this.validateOnSubmit = validateOnSubmit;
};

ClientValidator.prototype.setErrorClass = function(errorClass)
{
    this.errorClass = errorClass;
};

ClientValidator.prototype.setWarningClass = function(warningClass)
{
    this.warningClass = warningClass;
};

ClientValidator.prototype.getDependents = function()
{
    var dependents = new HashMap();
    var dependencies = this.getDependencies();
    if (dependencies !== null)
    {
        var context = FacesContext.getCurrentInstance();
        dependencies = dependencies.split(',');
        for (var i = 0; i < dependencies.length; i++)
        {
            // Split User and Client Id Sections
            var ids = dependencies[i].trim().split(';');
            if (ids.length !== 2)
            {
                continue;
            }

            // Get Actual Ids
            var userId = ids[0].trim();
            var clientId = ids[1].trim();

            // Get Component and Add to List
            var field = context.getComponent(null, clientId, true);
            dependents.put(userId, field);
        }
    }

    return dependents;
};

ClientValidator.prototype.getDependencies = function()
{
    return this.dependencies;
};

ClientValidator.prototype.setDependencies = function(dependencies)
{
    this.dependencies = dependencies;
};

ClientValidator.prototype.validate = function(context, component, value, event)
{
    // Get Message Type
    var type = LifecycleState.NONE;
    if (event === LifecycleEvent.ONSUBMIT)
    {
        type = this.getValidateOnSubmit();
    }
    else if (event === LifecycleEvent.ONINPUT)
    {
        type = this.getValidateOnInput();
    }
    else if (event === LifecycleEvent.ONCHANGE)
    {
        type = this.getValidateOnChange();
    }

    try
    {
        // Valiate if Valid
        if (type !== LifecycleState.NONE && this.validator !== null)
        {
            var dependents = this.getDependents();
            this.validator.validate(context, component, value, dependents);
        }
    }
    catch (exception)
    {
        // Get Message
        var summary = this.errorMessage;
        if (summary === null)
        {
            summary = (exception.message ? exception.message.summary : null);
        }

        var detail = this.errorDetail;
        if (detail === null)
        {
            detail = (exception.message ? exception.message.detail : null);
        }

        // Update Message
        var message = new FacesMessage(summary, detail);

        // Create Error
        var error =
            new ComponentMessage(component, this, message, type);

        // Add to Framework
        context.addError(error);

        // Return Failure
        return false;
    }

    // Success
    return true;
};

var Lifecycle = {};
Lifecycle.messenger = null;
Lifecycle.errorHandlers = null;
Lifecycle.validateFormFlag = true;

Lifecycle.initialize = function()
{
    // Check if Initialized
    if (this.initialized === true)
    {
        return;
    }

    // Setup Events
    //Lifecycle.addPageLoadEvent(Lifecycle.setupComponents);

    // Set Initialized
    this.initialized = true;
};

Lifecycle.addPageLoadEvent = function(func)
{
    // Initialize Events first Access
    if (window.pageLoadEvents == null)
    {
        // Setup Event List
        window.pageLoadEvents = [];
        if (window.onload != null)
        {
            window.pageLoadEvents.push(window.onload);
        }

        // Add Event
        window.onload = function(event)
        {
            var events = window.pageLoadEvents;
            for (var i = 0; i < events.length; i++)
            {
                if (typeof events[i] == "function")
                {
                    events[i](event);
                }
                else if (typeof events[i] == "string")
                {
                    eval(events[i]);
                }
            }
        };
    }

    // Add to List
    window.pageLoadEvents.push(func);
}

Lifecycle.setupComponents = function()
{
    // Process Each Form
    var forms = FacesContext.getCurrentInstance().getForms();
    for (var i = 0; i < forms.length; i++)
    {
        // Process Each Component
        var components = forms[i].getComponents();
        for (var j = 0; j < components.length; j++)
        {
            components[j].initialize();
        }
    }
};

Lifecycle.getMessenger = function()
{
    return this.messenger;
};

Lifecycle.setMessenger = function(messenger)
{
    this.messenger = messenger;
};

Lifecycle.addValidator = function(formId, clientId, validator)
{
    var context = FacesContext.getCurrentInstance();
    context.getComponent(formId, clientId, true).addValidator(validator);
};

Lifecycle.addConverter = function(formId, clientId, converter)
{
    var context = FacesContext.getCurrentInstance();
    context.getComponent(formId, clientId, true).setConverter(converter);
};

Lifecycle.addRenderer = function(formId, clientId, renderer)
{
    var context = FacesContext.getCurrentInstance();
    context.getComponent(formId, clientId, true).setRenderer(renderer);
};

Lifecycle.addMessenger = function(formId, clientId, messenger)
{
    var context = FacesContext.getCurrentInstance();
    context.getComponent(formId, clientId, true).setMessenger(messenger);
};

Lifecycle.getErrorHandlers = function()
{
    // Create Handlers on First Access
    if (this.errorHandlers === null)
    {
        this.errorHandlers = [];
        this.errorHandlers.push(new GlobalMessageHandler());
        this.errorHandlers.push(new MessageHandler());
        this.errorHandlers.push(new StyleHandler());
        this.errorHandlers.push(new AlertHandler());
    }

    // Return Handlers
    return this.errorHandlers;
};

Lifecycle.isValidateForm = function()
{
    return this.validateFormFlag;
};

Lifecycle.setValidateForm = function(validateFormFlag)
{
    this.validateFormFlag = validateFormFlag;
};

Lifecycle.validateForm = function(form)
{
    // Ignore if not Validating
    if (!this.isValidateForm())
    {
        return true;
    }

    // Get Current Context
    var context = FacesContext.getCurrentInstance();

    // Clear Errors & Messages
    context.clearErrors();

    // Get All Fields
    var clientId = null;
    var components = context.getComponents(form.id);
    for (var i = 0; i < components.length; i++)
    {
        // Validate Field
        var component = components[i];
        component.validate(context, LifecycleEvent.ONSUBMIT);
    }

    // Check if Errors
    if (context.hasErrors())
    {
        context.showErrors(true);
        return false;
    }

    // Success
    return true;
};

Lifecycle.validateFields = function(fields)
{
    // Get Current Context
    var context = FacesContext.getCurrentInstance();

    // Clear Errors & Messages
    context.clearErrors();

    // Get All Fields
    var clientId = null;
    for (var i = 0; i < fields.length; i++)
    {
        // Validate Field
        var component = context.findComponent(fields[i]);
        if (component)
        {
            component.validate(context, LifecycleEvent.ONSUBMIT);
        }
    }

    // Check if Errors
    if (context.hasErrors())
    {
        context.showErrors(true);
        return false;
    }

    // Success
    return true;
};

Lifecycle.validateField = function(component, evt, eventType)
{
    // Get Current Context
    var context = FacesContext.getCurrentInstance();

    // Clear Errors
    context.clearErrors();

    // Validate Field
    component.validate(context, eventType);

    // Check if Errors
    if (context.hasErrors())
    {
        context.showErrors();
        return false;
    }

    // Success
    return true;
};

Lifecycle.validateInput = function(component, evt)
{
    // Get Current Context
    var context = FacesContext.getCurrentInstance();

    // Get Input
    var code = null;
    if (evt.keyCode)
    {
        code = evt.keyCode;
    }
    else if (evt.which)
    {
        code = evt.which;
    }

    // Validate Only Printable Codes
    if (code === 32 || (code > 38 && code < 177))
    {
        return component.checkInput(context, String.fromCharCode(code));
    }
};

function FacesContext()
{
    // Setup Properties
    this.forms = new HashMap();

    // Create parameter map
    this.requestParams = new RequestParameterMap();
}

FacesContext.getCurrentInstance = function()
{
    // Create initial context
    if (!FacesContext.INSTANCE)
    {
        FacesContext.INSTANCE = new FacesContext();
    }

    // Return instance
    return FacesContext.INSTANCE;
};

FacesContext.prototype.getRequestParameterMap = function()
{
    return this.requestParams;
};

FacesContext.prototype.getForms = function()
{
    return this.forms.values();
};

FacesContext.prototype.getForm = function(formId, autoCreate)
{
    // Validate Parameters
    if (!formId)
    {
        return null;
    }

    // Setup Default Values
    autoCreate = (autoCreate || false);

    // Get Associated Form
    var form = this.forms.get(formId);

    // Create If Necessary
    if (!form && autoCreate)
    {
        form = new ClientForm(formId);
        this.forms.put(formId, form);
    }

    // Return Form
    return form;
};

FacesContext.prototype.getComponents = function(formId)
{
    // Get Components from Form
    var components = [];
    var form = this.forms.get(formId);
    if (form)
    {
        components = form.getComponents();
    }

    // Return Components
    return components;
};

FacesContext.prototype.getComponent = function(formId, clientId, autoCreate)
{
    // Validate Parameters
    if (!clientId)
    {
        return null;
    }

    // Setup Default Values
    autoCreate = (autoCreate || false);

    // Get Associated Form
    var form = null;
    if (!formId)
    {
        var forms = this.getForms();
        if (forms !== null && forms.length > 0)
        {
            form = forms[0];
        }
        else
        {
            // Attempt to Auto-Create
            form = this.getForm(document.forms[0].id, autoCreate);
        }
    }
    else
    {
        form = this.getForm(formId, autoCreate);
    }

    // Get Component
    var component = null;
    if (form !== null)
    {
        component = form.getComponent(clientId, autoCreate);
    }

    // Return Component
    return component;
};

FacesContext.prototype.findComponent = function(clientId)
{
    // Search Each Form
    var forms = this.getForms();
    for (var i = 0; i < forms.length; i++)
    {
        var component = forms[i].findComponent(clientId);
        if (component !== null)
        {
            return component;
        }
    }

    // None Found
    return null;
};

FacesContext.prototype.clearErrors = function()
{
    // Reset Error Flag
    this.errorCount = 0;

    // Get Handlers
    var handlers = Lifecycle.getErrorHandlers();

    // Clear Error of all Handlers
    for (var i = 0; i < handlers.length; i++)
    {
        handlers[i].clearErrors();
    }
};

FacesContext.prototype.addError = function(error)
{
    // Update Error Flag
    this.errorCount++;

    // Get Handlers
    var handlers = Lifecycle.getErrorHandlers();

    // Clear Error of all Handlers
    for (var i = 0; i < handlers.length; i++)
    {
        handlers[i].addError(error);
    }
};

FacesContext.prototype.hasErrors = function()
{
    return (this.errorCount > 0 ? true : false);
};

FacesContext.prototype.showErrors = function(showGlobal)
{
    // Setup Defaults
    showGlobal = (showGlobal || false);

    // Get Error Handlers
    var handlers = Lifecycle.getErrorHandlers();

    // Show Errors in Each Handler
    for (var i = 0; i < handlers.length; i++)
    {
        if (!(handlers[i] instanceof GlobalMessageHandler) || showGlobal)
        {
            handlers[i].showErrors();
        }
    }
};

function RequestParameterMap() {}

RequestParameterMap.prototype.get = function(id)
{
    // Get the Associated Field
    var field = this.getField(id);
    if (field === null)
    {
        return null;
    }

    // Handle Radio Buttons
    if ((field.type === 'radio') ||
        (field.length > 0 && field[0].type === 'radio'))
    {
        return this.getButtonValue(!field.length ? [ field ] : field);
    }

    // Handle Checkboxes
    else if ((field.type === 'checkbox') ||
        (field.length > 0 && field[0].type === 'checkbox'))
    {
        return this.getButtonValue(!field.length ? [ field ] : field);
    }

    // Handle Select Boxes
    else if (field.options)
    {
        return this.getSelectValue(field);
    }

    // Handle Text Fields
    else if (field.type === 'text' || field.type === 'hidden' ||
             field.type === 'textarea' || field.type === 'button' ||
             field.type === 'submit' || field.type === 'reset' ||
             field.type === 'password')
    {
        return this.getTextValue(field);
    }

    // Otherwise, Handle HTML Fields
    else
    {
        return this.getHtmlValue(field);
    }

    // Unknown Field
    return null;
};

RequestParameterMap.prototype.set = function(id, value)
{
    // Get the Associated Field
    var field = this.getField(id);
    if (field === null)
    {
        return;
    }

    // Handle Radio Buttons
    if ((field.type === 'radio') ||
        (field.length > 0 && field[0].type === 'radio'))
    {
        return this.setButtonValue(!field.length ? [ field ] : field,
                                   value);
    }

    // Handle Checkboxes
    else if ((field.type === 'checkbox') ||
        (field.length > 0 && field[0].type === 'checkbox'))
    {
        return this.setButtonValue(!field.length ? [ field ] : field,
                                   value);
    }

    // Handle Select Boxes
    else if (field.options)
    {
        return this.setSelectValue(field, value);
    }

    // Handle Text Feilds
    else if (field.type === 'text' || field.type === 'hidden' ||
             field.type === 'textarea' || field.type === 'button' ||
             field.type === 'submit' || field.type === 'reset' ||
             field.type === 'password')
    {
        return this.setTextValue(field, value);
    }

    // Otherwise, Update InnerHTML
    else
    {
        return this.setHtmlValue(field, value);
    }
};

RequestParameterMap.prototype.getField = function(id)
{
    // Get Field from Document
    var field = document.getElementById(id);
    if (!field)
    {
        var forms = document.forms;
        for (var i = 0; i < forms.length; i++)
        {
            var fields = document.forms[i].elements;
            field = fields[id];
            if (field) { break; }
        }
    }

    return field;
}

RequestParameterMap.prototype.getTextValue = function(field)
{
    // Get Field Value if Available
    return (!field ? null : field.value);
};

RequestParameterMap.prototype.setTextValue = function(field, value)
{
    // Set Field Value if Available
    if (field)
    {
        field.value = value;
    }
};

RequestParameterMap.prototype.getButtonValue = function(field)
{
    // Verify Field
    if (!field || !field.length)
    {
        return null;
    }

    // Get Checked Button
    for (var i = 0; i < field.length; i++)
    {
        if (field[i].checked)
        {
            return field[i].value;
        }
    }

    // None Found
    return null;
};

RequestParameterMap.prototype.setButtonValue = function(field, value)
{
    // Verify Field
    if (!field || !field.length)
    {
        return;
    }

    // Get Buttons to Check
    for (var i = 0; i < field.length; i++)
    {
        if (field[i].value === value)
        {
            field[i].checked = true;
        }
    }
};

RequestParameterMap.prototype.getSelectValue = function(field)
{
    // Verify Field
    if (!field || !field.options)
    {
        return null;
    }

    // Get Selected Index
    var selectedIndex = field.selectedIndex;
    if (selectedIndex !== null && selectedIndex >= 0)
    {
        return field.options[selectedIndex].value;
    }

    // None Selected
    return null;
};

RequestParameterMap.prototype.setSelectValue = function(field, value)
{
    // Verify Field
    if (!field || !field.options)
    {
        return;
    }

    // Get Selected Index to Select
    for (var i = 0; i < field.options.length; i++)
    {
        if (field.options[i].value === value)
        {
            field.selectedIndex = i;
            break;
        }
    }
};

RequestParameterMap.prototype.getHtmlValue = function(field)
{
    // Get Field HTML if Available
    return (!field ? null : field.innerHTML);
};

RequestParameterMap.prototype.setHtmlValue = function(field, value)
{
    // Set Field Value if Available
    if (field)
    {
        field.innerHTML = value;
    }
};

Lifecycle.initialize();