package com.njcn.event;

import com.njcn.event.pojo.PqsEventDetail;
import com.njcn.event.pojo.PqsOnlinerateAggregate;
import com.njcn.event.pojo.PqsEventDetailCount;
import com.njcn.influxdb.utils.InfluxDbUtils;
import org.influxdb.dto.QueryResult;
import org.influxdb.impl.InfluxDBResultMapper;
import org.influxdb.querybuilder.SelectQueryImpl;
import org.influxdb.querybuilder.SelectionQueryImpl;
import org.influxdb.querybuilder.WhereNested;
import org.influxdb.querybuilder.WhereQueryImpl;
import org.influxdb.querybuilder.clauses.Clause;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Arrays;
import java.util.List;

import static com.njcn.influxdb.param.InfluxDBPublicParam.DATABASE;
import static com.njcn.influxdb.param.InfluxDBPublicParam.PQS_EVENT_DETAIL;
import static org.influxdb.querybuilder.BuiltQuery.QueryBuilder.*;
import static org.influxdb.querybuilder.FunctionFactory.sum;


@RunWith(SpringRunner.class)
@SpringBootTest
public class EventBootApplicationTest {
    
    
    @Autowired
    private InfluxDbUtils influxDbUtils;
    
    // TODO https://github.com/influxdata/influxdb-java/blob/master/QUERY_BUILDER.md
    
    @Test
    public void queryList() {
        // or 条件数据
        List<Clause> clauses = getClauses();
        
        SelectQueryImpl selectQuery = select().column("line_id").column("eventass_index").from(DATABASE, PQS_EVENT_DETAIL);
        WhereQueryImpl<SelectQueryImpl> where = selectQuery.where();
        
        // WHERE (line_id = '1' OR line_id = '2' OR line_id = '3')   加上前后()
        whereAndNested(clauses, where);
        
        // AND time >= '2022-05-01T00:00:00Z' AND time <= '2022-09-01T00:00:00Z' tz('Asia/Shanghai');
        where.and(gte("time", "2022-05-01T00:00:00Z")).and(lte("time", "2022-09-01T00:00:00Z"));
        where.tz("Asia/Shanghai");
        
        QueryResult result = influxDbUtils.query(selectQuery.getCommand());
        InfluxDBResultMapper influxDBResultMapper = new InfluxDBResultMapper();
        List<PqsEventDetail> re = influxDBResultMapper.toPOJO(result, PqsEventDetail.class);
        Assert.assertTrue(re.size() > 0);
    }
    
    @Test
    public void queryCount() {
        // or 条件数据
        List<Clause> clauses = getClauses();
        
        SelectQueryImpl selectQuery = select().count("eventass_index").from(DATABASE, PQS_EVENT_DETAIL);
        WhereQueryImpl<SelectQueryImpl> where = selectQuery.where();
        
        // WHERE (line_id = '1' OR line_id = '2' OR line_id = '3')   加上前后()
        whereAndNested(clauses, where);
        
        // AND time >= '2022-05-01T00:00:00Z' AND time <= '2022-09-01T00:00:00Z' tz('Asia/Shanghai');
        where.and(gte("time", "2022-05-01T00:00:00Z")).and(lte("time", "2022-09-01T00:00:00Z"));
        where.tz("Asia/Shanghai");
        
        QueryResult result = influxDbUtils.query(selectQuery.getCommand());
        InfluxDBResultMapper influxDBResultMapper = new InfluxDBResultMapper();
        List<PqsEventDetailCount> re = influxDBResultMapper.toPOJO(result, PqsEventDetailCount.class);
        Assert.assertTrue(re.size() > 0);
    }
    
    @Test
    public void queryAggregate() {
        
        // SELECT (SUM(onlinemin) / (SUM(onlinemin) + SUM(offlinemin))) * 100 FROM pqs_onlinerate
        SelectionQueryImpl select = select();
        SelectionQueryImpl sum = select.op(op(sum("onlinemin"), "/", op(sum("onlinemin"), "+", sum("offlinemin"))), "*", 100)
                .as("value");
        SelectQueryImpl selectQuery = sum.from(DATABASE, "pqs_onlinerate");
        WhereQueryImpl<SelectQueryImpl> where = selectQuery.where();
        
        // AND time >= '2022-05-01T00:00:00Z' AND time <= '2022-09-01T00:00:00Z' tz('Asia/Shanghai');
        where.and(gte("time", "2022-05-01T00:00:00Z")).and(lte("time", "2022-09-01T00:00:00Z"));
        where.tz("Asia/Shanghai");
        
        QueryResult result = influxDbUtils.query(selectQuery.getCommand());
        InfluxDBResultMapper influxDBResultMapper = new InfluxDBResultMapper();
        List<PqsOnlinerateAggregate> re = influxDBResultMapper.toPOJO(result, PqsOnlinerateAggregate.class);
        Assert.assertTrue(re.size() > 0);
    }
    
    private List<Clause> getClauses() {
        Clause c1 = eq("line_id", "5e467a40023b299070682eb21f2ec9a1");
        Clause c2 = eq("line_id", "183245996f303ebfd80eeb3377cecdc2");
        Clause c3 = eq("line_id", "0d46f54420246e999d5c68b3133f668c");
        
        return Arrays.asList(c1, c2, c3);
    }
    
    private void whereAndNested(List<Clause> clauses, WhereQueryImpl<SelectQueryImpl> whereQuery) {
        WhereNested<WhereQueryImpl<SelectQueryImpl>> andNested = whereQuery.andNested();
        for (Clause clause : clauses) {
            andNested.or(clause);
        }
        andNested.close();
    }
    
}