//------------------------------------------------------------------------------
// <copyright file="CompareValidator.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------

namespace System.Web.UI.WebControls {

    using System.ComponentModel;
    using System.Web;
    using System.Globalization;
    using System.Web.Util;


    /// <devdoc>
    ///    <para> Compares the value of an input control to another input control or
    ///       a constant value using a variety of operators and types.</para>
    /// </devdoc>
    [
    ToolboxData("<{0}:CompareValidator runat=\"server\" ErrorMessage=\"CompareValidator\"></{0}:CompareValidator>")
    ]
    public class CompareValidator : BaseCompareValidator {


        /// <devdoc>
        ///    <para>Gets or sets the ID of the input control to compare with.</para>
        /// </devdoc>
        [
        WebCategory("Behavior"),
        Themeable(false),
        DefaultValue(""),
        WebSysDescription(SR.CompareValidator_ControlToCompare),
        TypeConverter(typeof(ValidatedControlConverter))
        ]                                         
        public string ControlToCompare {
            get { 
                object o = ViewState["ControlToCompare"];
                return((o == null) ? String.Empty : (string)o);
            }
            set {
                ViewState["ControlToCompare"] = value;
            }
        }


        /// <devdoc>
        ///    <para>Gets or sets the comparison operation to perform.</para>
        /// </devdoc>
        [
        WebCategory("Behavior"),
        Themeable(false),
        DefaultValue(ValidationCompareOperator.Equal),
        WebSysDescription(SR.CompareValidator_Operator)
        ]                                         
        public ValidationCompareOperator Operator {
            get { 
                object o = ViewState["Operator"];
                return((o == null) ? ValidationCompareOperator.Equal : (ValidationCompareOperator)o);
            }
            set {
                if (value < ValidationCompareOperator.Equal || value > ValidationCompareOperator.DataTypeCheck) {
                    throw new ArgumentOutOfRangeException("value");
                }
                ViewState["Operator"] = value;
            }
        }


        /// <devdoc>
        ///    <para>Gets or sets the specific value to compare with.</para>
        /// </devdoc>
        [
        WebCategory("Behavior"),
        Themeable(false),
        DefaultValue(""),
        WebSysDescription(SR.CompareValidator_ValueToCompare)
        ]                                         
        public string ValueToCompare {
            get { 
                object o = ViewState["ValueToCompare"];
                return((o == null) ? String.Empty : (string)o);
            }
            set {
                ViewState["ValueToCompare"] = value;
            }        
        }

        // <summary>
        //  AddAttributesToRender method
        // </summary>

        /// <internalonly/>
        /// <devdoc>
        ///    <para>Adds the attributes of this control to the output stream for rendering on the 
        ///       client.</para>
        /// </devdoc>
        protected override void AddAttributesToRender(HtmlTextWriter writer) {
            base.AddAttributesToRender(writer);
            if (RenderUplevel) {
                string id = ClientID;
                HtmlTextWriter expandoAttributeWriter = (EnableLegacyRendering || IsUnobtrusive) ? writer : null;
                AddExpandoAttribute(expandoAttributeWriter, id, "evaluationfunction", "CompareValidatorEvaluateIsValid", false);
                if (ControlToCompare.Length > 0) {
                    string controlToCompareID = GetControlRenderID(ControlToCompare);
                    AddExpandoAttribute(expandoAttributeWriter, id, "controltocompare", controlToCompareID);
                    AddExpandoAttribute(expandoAttributeWriter, id, "controlhookup", controlToCompareID);
                }
                if (ValueToCompare.Length > 0) {

                    string valueToCompareString = ValueToCompare;
                    if (CultureInvariantValues) {
                        valueToCompareString = ConvertCultureInvariantToCurrentCultureFormat(valueToCompareString, Type);
                    }
                    AddExpandoAttribute(expandoAttributeWriter, id, "valuetocompare", valueToCompareString);
                }
                if (Operator != ValidationCompareOperator.Equal) {
                    AddExpandoAttribute(expandoAttributeWriter, id, "operator", PropertyConverter.EnumToString(typeof(ValidationCompareOperator), Operator), false);
                }
            }
        }        


        /// <internalonly/>
        /// <devdoc>
        ///    <para> Checks the properties of a the control for valid values.</para>
        /// </devdoc>
        protected override bool ControlPropertiesValid() {

            // Check the control id references 
            if (ControlToCompare.Length > 0) {
                CheckControlValidationProperty(ControlToCompare, "ControlToCompare");

                if (StringUtil.EqualsIgnoreCase(ControlToValidate, ControlToCompare)) {
                    throw new HttpException(SR.GetString(SR.Validator_bad_compare_control, 
                                                                             ID, 
                                                                             ControlToCompare));
                }
            }   
            else {
                // Check Values
                if (Operator != ValidationCompareOperator.DataTypeCheck &&
                    !CanConvert(ValueToCompare, Type, CultureInvariantValues)) {
                        throw new HttpException(
                                           SR.GetString(SR.Validator_value_bad_type, 
                                                                           new string [] {
                                                                               ValueToCompare,
                                                                               "ValueToCompare",
                                                                               ID, 
                                                                               PropertyConverter.EnumToString(typeof(ValidationDataType), Type),
                                                                           }));
                }
            }
            return base.ControlPropertiesValid();
        }


        /// <internalonly/>
        /// <devdoc>
        ///    EvaluateIsValid method
        /// </devdoc>
        protected override bool EvaluateIsValid() {

            Debug.Assert(PropertiesValid, "Properties should have already been checked");

            // Get the peices of text from the control.
            string leftText = GetControlValidationValue(ControlToValidate);
            Debug.Assert(leftText != null, "Should have already caught this!");

            // Special case: if the string is blank, we don't try to validate it. The input should be
            // trimmed for coordination with the RequiredFieldValidator.
            if (leftText.Trim().Length == 0) {
                return true;
            }

            // VSWhidbey 83168
            bool convertDate = (Type == ValidationDataType.Date && !DetermineRenderUplevel());
            if (convertDate && !IsInStandardDateFormat(leftText)) {
                leftText = ConvertToShortDateString(leftText);
            }

            // The control has precedence over the fixed value
            bool isCultureInvariantValue = false;
            string rightText = string.Empty;
            if (ControlToCompare.Length > 0) {
                rightText = GetControlValidationValue(ControlToCompare);
                Debug.Assert(rightText != null, "Should have already caught this!");

                // VSWhidbey 83089
                if (convertDate && !IsInStandardDateFormat(rightText)) {
                    rightText = ConvertToShortDateString(rightText);
                }
            }
            else {
                rightText = ValueToCompare;
                isCultureInvariantValue = CultureInvariantValues;
            }

            return Compare(leftText, false, rightText, isCultureInvariantValue, Operator, Type);

        }
    }
}