/*
 *  Copyright 2019 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.cms.search.query;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.format.ResolverStyle;

import org.ametys.core.util.date.AdaptableDate;

/**
 * Represents a {@link Query} testing a date field.
 */
public class DateQuery extends AbstractFieldQuery
{
    /** The date formatter */
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
            .withResolverStyle(ResolverStyle.STRICT);
    
    /** The operator. */
    protected Operator _operator;
    /** The value to test. */
    protected AdaptableDate _value;
    
    /**
     * Build a DateQuery testing the existence of the field.
     * @param fieldPath the field path.
     */
    public DateQuery(String fieldPath)
    {
        this(fieldPath, Operator.EXISTS, (AdaptableDate) null);
    }
    
    /**
     * Build a DateQuery.
     * @param fieldPath the field's path
     * @param value the value.
     */
    public DateQuery(String fieldPath, LocalDate value)
    {
        this(fieldPath, AdaptableDate.fromDate(value));
    }
    
    /**
     * Build a DateQuery.
     * @param fieldPath the field's path
     * @param value the value.
     */
    public DateQuery(String fieldPath, AdaptableDate value)
    {
        this(fieldPath, Operator.EQ, value);
    }
    
    /**
     * Build a DateQuery.
     * @param fieldPath the field's path
     * @param op the operator.
     * @param value the value.
     */
    public DateQuery(String fieldPath, Operator op, LocalDate value)
    {
        this(fieldPath, op, AdaptableDate.fromDate(value));
    }
    
    /**
     * Build a DateQuery.
     * @param fieldPath the field's path
     * @param op the operator.
     * @param value the value.
     */
    public DateQuery(String fieldPath, Operator op, AdaptableDate value)
    {
        super(fieldPath);
        _operator = op;
        _value = value;
    }
    
    /**
     * Get the operator.
     * @return the operator.
     */
    public Operator getOperator()
    {
        return _operator;
    }
    
    /**
     * Get the value.
     * @return the value.
     */
    public AdaptableDate getValue()
    {
        return _value;
    }
    
    @Override
    public String build() throws QuerySyntaxException
    {
        StringBuilder query = new StringBuilder();
        
        if (_operator == Operator.NE)
        {
            NotQuery.appendNegation(query);
        }
        
        query.append(_fieldPath).append("_dt:");
        
        if (_operator == Operator.EXISTS)
        {
            query.append(QueryHelper.EXISTS_VALUE);
        }
        else
        {
            appendDateValue(query, _operator, _value);
        }
        
        return query.toString();
    }
    
    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = super.hashCode();
        result = prime * result + ((_operator == null) ? 0 : _operator.hashCode());
        result = prime * result + ((_value == null) ? 0 : _value.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (!super.equals(obj))
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        DateQuery other = (DateQuery) obj;
        if (_operator != other._operator)
        {
            return false;
        }
        if (_value == null)
        {
            if (other._value != null)
            {
                return false;
            }
        }
        else if (!_value.equals(other._value))
        {
            return false;
        }
        return true;
    }

    /**
     * Format and append the given date to a StringBuilder.
     * @param query The string builder containing the query being built.
     * @param operator The query operator.
     * @param value The test value.
     */
    public static void appendDateValue(StringBuilder query, Operator operator, AdaptableDate value)
    {
        if (operator == Operator.EQ || operator == Operator.NE)
        {
            LocalDate date = value.resolveDate();
            query.append('[')
                .append(date.atStartOfDay().format(DATE_FORMATTER))
                .append(" TO ")
                .append(date.atTime(LocalTime.MAX).format(DATE_FORMATTER))
                .append(']');
            return;
        }
        
        String strValue = _format(value, operator);
        if (operator == Operator.GT)
        {
            query.append('{').append(strValue).append(" TO *]");
        }
        else if (operator == Operator.GE)
        {
            query.append('[').append(strValue).append(" TO *]");
        }
        else if (operator == Operator.LT)
        {
            query.append("[* TO ").append(strValue).append('}');
        }
        else if (operator == Operator.LE)
        {
            query.append("[* TO ").append(strValue).append(']');
        }
    }
    
    private static String _format(AdaptableDate value, Operator operator)
    {
        LocalDate date = value.resolveDate();
        // We are doing this because:
        // In Solr we store datetimes
        // But (for the moment), we handle querying on dates only
        // So the AdaptableDate ('value') is resolved as a LocalDate (thus, at the moment of this method call, 'date' has lost any time information)
        // Then, depending on the operator, we specify the min or max time of the day to handle range
        // Finally, we format the LocalDateTime to a readable string by Solr parser
        // 
        // Note: in the future, if we need to support querying on complete datetimes, we should call value.resolveDateTime() instead of value.resolveDate() (in a DateTimeQuery of course)
        LocalDateTime dateTime;
        if (Operator.LE == operator || Operator.GT == operator)
        {
            // LE: all datetimes of upper bound no matter their time should be included
            // GT: all datetimes of lower bound no matter their time should be excluded
            dateTime = date.atTime(LocalTime.MAX);
        }
        else
        {
            // GE: all datetimes of lower bound no matter their time should be included
            // LT: all datetimes of upper bound no matter their time should be excluded
            dateTime = date.atStartOfDay();
        }
        return dateTime.format(DATE_FORMATTER);
    }
    
}