/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */
#ifndef READER_EXPRESSION_H
#define READER_EXPRESSION_H

#include <string>
#include <vector>

#include "common/db_common.h"
#include "common/path.h"
#include "filter/filter.h"

namespace storage {

class Filter;

enum ExpressionType {
    AND_EXPR,
    OR_EXPR,
    SERIES_EXPR,
    GLOBALTIME_EXPR,
    INVALID_EXPR
};

struct Expression {
    ExpressionType type_;
    Expression* left_;
    Expression* right_;
    Filter* filter_;
    Path series_path_;

    Expression(ExpressionType t)
        : type_(t),
          left_(nullptr),
          right_(nullptr),
          filter_(nullptr),
          series_path_() {}
    Expression(ExpressionType t, Expression* l, Expression* r)
        : type_(t), left_(l), right_(r), filter_(nullptr), series_path_() {}
    Expression(ExpressionType t, Filter* f)
        : type_(t),
          left_(nullptr),
          right_(nullptr),
          filter_(f),
          series_path_() {}
    Expression(ExpressionType t, const Path& path, Filter* f)
        : type_(t),
          left_(nullptr),
          right_(nullptr),
          filter_(f),
          series_path_(path) {}
    void destroy() {
        if (filter_ != nullptr) {
            delete filter_;
            filter_ = nullptr;
        }
        if (left_ != nullptr) {
            delete left_;
            left_ = nullptr;
        }
        if (right_ != nullptr) {
            delete right_;
            right_ = nullptr;
        }
    }
    ~Expression() { destroy(); }
};

class QueryExpression {
   public:
    QueryExpression() : has_filter_(false), expression_(nullptr) {}
    ~QueryExpression() { destory(); }

    static QueryExpression* create(const std::vector<Path>& selected_series,
                                   Expression* expression) {
        QueryExpression* ret = new QueryExpression();
        ret->selected_series_ = selected_series;
        ret->expression_ = expression;
        ret->has_filter_ = (expression != nullptr);
        return ret;
    }
    static void destory(QueryExpression* expr) {
        if (expr) {
            delete expr;
        }
    }
    FORCE_INLINE void set_select_series(
        const std::vector<Path>& selected_series) {
        selected_series_ = selected_series;
    }
    FORCE_INLINE void add_select_series(const Path& path) {
        selected_series_.push_back(path);
    }
    FORCE_INLINE void set_expression(Expression* expression) {
        if (expression) {
            expression_ = expression;
            has_filter_ = true;
        }
    }
    Expression* optimize(Expression* expression,
                         std::vector<Path>& series_paths);
    void destory();

   private:
    Expression* combine_two_global_time_filter(Expression* left,
                                               Expression* right,
                                               ExpressionType type);
    Expression* handle_one_global_time_filter(
        Expression* left, Expression* expression,
        std::vector<Path>& selected_series, ExpressionType type);
    void add_time_filter_to_query_filter(Filter* time_filter,
                                         Expression* expression);
    void add_time_filter_to_series_filter(Filter* time_filter,
                                          Expression* single_series_expr);
    Expression* push_global_time_filter_to_all_series(
        Expression* time_filter, std::vector<Path>& selected_series);
    Expression* merge_second_tree_to_first_tree(Expression* left_expression,
                                                Expression* right_expression);
    bool update_filter_with_or(Expression* expression, Filter* filter,
                               Path& path);

   public:
    bool has_filter_;
    std::vector<Path> selected_series_;
    std::vector<common::TSDataType> data_types_;
    Expression* expression_;
    std::vector<Expression*> my_exprs_;
    std::vector<Filter*> my_filters_;
};

}  // namespace storage

#endif  // READER_EXPRESSION_H