/*
 * Copyright (c) 2017 Google Inc. All Rights Reserved.
 *
 * 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 com.android.vts.servlet;

import com.android.vts.entity.CodeCoverageEntity;
import com.android.vts.entity.DeviceInfoEntity;
import com.android.vts.entity.TestCoverageStatusEntity;
import com.android.vts.entity.TestEntity;
import com.android.vts.entity.TestRunEntity;

import com.android.vts.proto.VtsReportMessage;
import com.android.vts.util.FilterUtil;
import com.google.cloud.datastore.Datastore;
import com.google.cloud.datastore.DatastoreOptions;
import com.google.cloud.datastore.PathElement;
import com.google.cloud.datastore.StructuredQuery.CompositeFilter;
import com.google.cloud.datastore.StructuredQuery.Filter;
import com.google.cloud.datastore.StructuredQuery.PropertyFilter;
import com.google.gson.Gson;
import com.google.visualization.datasource.DataSourceHelper;
import com.google.visualization.datasource.DataSourceRequest;
import com.google.visualization.datasource.base.DataSourceException;
import com.google.visualization.datasource.base.ReasonType;
import com.google.visualization.datasource.base.ResponseStatus;
import com.google.visualization.datasource.base.StatusType;
import com.google.visualization.datasource.base.TypeMismatchException;
import com.google.visualization.datasource.datatable.ColumnDescription;
import com.google.visualization.datasource.datatable.DataTable;
import com.google.visualization.datasource.datatable.TableRow;
import com.google.visualization.datasource.datatable.value.DateTimeValue;
import com.google.visualization.datasource.datatable.value.NumberValue;
import com.google.visualization.datasource.datatable.value.ValueType;
import com.googlecode.objectify.Key;
import com.ibm.icu.util.GregorianCalendar;
import com.ibm.icu.util.TimeZone;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.logging.Level;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import static com.googlecode.objectify.ObjectifyService.ofy;

/** Represents the servlet that is invoked on loading the coverage overview page. */
public class ShowCoverageOverviewServlet extends BaseServlet {

    @Override
    public PageType getNavParentType() {
        return PageType.COVERAGE_OVERVIEW;
    }

    @Override
    public List<Page> getBreadcrumbLinks(HttpServletRequest request) {
        return null;
    }

    @Override
    public void doGetHandler(HttpServletRequest request, HttpServletResponse response)
            throws IOException {

        String pageType =
                request.getParameter("pageType") == null
                        ? "html"
                        : request.getParameter("pageType");

        RequestDispatcher dispatcher;
        if (pageType.equalsIgnoreCase("html")) {
            dispatcher = this.getCoverageDispatcher(request, response);
            try {
                request.setAttribute("pageType", pageType);
                response.setStatus(HttpServletResponse.SC_OK);
                dispatcher.forward(request, response);
            } catch (ServletException e) {
                logger.log(Level.SEVERE, "Servlet Exception caught : ", e);
            }
        } else {

            String testName = request.getParameter("testName");

            DataTable data = getCoverageDataTable(testName);
            DataSourceRequest dsRequest = null;

            try {
                // Extract the datasource request parameters.
                dsRequest = new DataSourceRequest(request);

                // NOTE: If you want to work in restricted mode, which means that only
                // requests from the same domain can access the data source, uncomment the following
                // call.
                //
                // DataSourceHelper.verifyAccessApproved(dsRequest);

                // Apply the query to the data table.
                DataTable newData =
                        DataSourceHelper.applyQuery(
                                dsRequest.getQuery(), data, dsRequest.getUserLocale());

                // Set the response.
                DataSourceHelper.setServletResponse(newData, dsRequest, response);
            } catch (RuntimeException rte) {
                logger.log(Level.SEVERE, "A runtime exception has occured", rte);
                ResponseStatus status =
                        new ResponseStatus(
                                StatusType.ERROR, ReasonType.INTERNAL_ERROR, rte.getMessage());
                if (dsRequest == null) {
                    dsRequest = DataSourceRequest.getDefaultDataSourceRequest(request);
                }
                DataSourceHelper.setServletErrorResponse(status, dsRequest, response);
            } catch (DataSourceException e) {
                if (dsRequest != null) {
                    DataSourceHelper.setServletErrorResponse(e, dsRequest, response);
                } else {
                    DataSourceHelper.setServletErrorResponse(e, request, response);
                }
            }
        }
    }

    private List<Key<TestRunEntity>> getTestRunEntityKeyList(
            List<TestCoverageStatusEntity> testCoverageStatusEntityList) {
        return testCoverageStatusEntityList.stream()
                .map(
                        testCoverageStatusEntity -> {
                            com.googlecode.objectify.Key testKey =
                                    com.googlecode.objectify.Key.create(
                                            TestEntity.class,
                                            testCoverageStatusEntity.getTestName());
                            return com.googlecode.objectify.Key.create(
                                    testKey,
                                    TestRunEntity.class,
                                    testCoverageStatusEntity.getUpdatedTimestamp());
                        })
                .collect(Collectors.toList());
    }

    private Predicate<DeviceInfoEntity> isBranchAndDevice(String branch, String device) {
        return d -> d.getBranch().equals(branch) && d.getBuildFlavor().equals(device);
    }

    private Predicate<DeviceInfoEntity> isBranch(String branch) {
        return d -> d.getBranch().equals(branch);
    }

    private Predicate<DeviceInfoEntity> isDevice(String device) {
        return d -> d.getBuildFlavor().equals(device);
    }

    private RequestDispatcher getCoverageDispatcher(
            HttpServletRequest request, HttpServletResponse response) {

        String COVERAGE_OVERVIEW_JSP = "WEB-INF/jsp/show_coverage_overview.jsp";

        RequestDispatcher dispatcher = null;
        boolean unfiltered = request.getParameter("unfiltered") != null;
        boolean showPresubmit = request.getParameter("showPresubmit") != null;
        boolean showPostsubmit = request.getParameter("showPostsubmit") != null;

        // If no params are specified, set to default of postsubmit-only.
        if (!(showPresubmit || showPostsubmit)) {
            showPostsubmit = true;
        }

        // If unfiltered, set showPre- and Post-submit to true for accurate UI.
        if (unfiltered) {
            showPostsubmit = true;
            showPresubmit = true;
        }

        // Add test names to list
        List<String> resultNames =
                Arrays.stream(VtsReportMessage.TestCaseResult.values())
                        .map(testCaseResult -> testCaseResult.name())
                        .collect(Collectors.toList());

        Map<String, String[]> parameterMap = request.getParameterMap();

        List<TestCoverageStatusEntity> testCoverageStatusEntityList =
                TestCoverageStatusEntity.getAllTestCoverage();

        List<com.googlecode.objectify.Key<TestRunEntity>> testRunEntityKeyList = new ArrayList<>();

        if (Objects.nonNull(parameterMap.get("branch"))
                || Objects.nonNull(parameterMap.get("device"))) {
            List<com.googlecode.objectify.Key<DeviceInfoEntity>> deviceInfoEntityKeyList =
                    TestCoverageStatusEntity.getDeviceInfoEntityKeyList(
                            testCoverageStatusEntityList);

            Collection<DeviceInfoEntity> deviceInfoEntityMap =
                    ofy().load().keys(() -> deviceInfoEntityKeyList.iterator()).values();

            Stream<DeviceInfoEntity> deviceInfoEntityStream = Stream.empty();
            if (Objects.nonNull(parameterMap.get("branch"))
                    && Objects.nonNull(parameterMap.get("device"))) {
                String branch = parameterMap.get("branch")[0];
                String device = parameterMap.get("device")[0];
                deviceInfoEntityStream =
                        deviceInfoEntityMap.stream().filter(isBranchAndDevice(branch, device));
            } else if (Objects.nonNull(parameterMap.get("branch"))) {
                String branch = parameterMap.get("branch")[0];
                deviceInfoEntityStream = deviceInfoEntityMap.stream().filter(isBranch(branch));
            } else if (Objects.nonNull(parameterMap.get("device"))) {
                String device = parameterMap.get("device")[0];
                deviceInfoEntityStream = deviceInfoEntityMap.stream().filter(isDevice(device));
            } else {
                logger.log(Level.WARNING, "unmet search condition!");
            }
            testRunEntityKeyList =
                    deviceInfoEntityStream
                            .map(
                                    deviceInfoEntity -> {
                                        com.googlecode.objectify.Key testKey =
                                                com.googlecode.objectify.Key.create(
                                                        TestEntity.class,
                                                        deviceInfoEntity
                                                                .getParent()
                                                                .getParent()
                                                                .getName());
                                        return com.googlecode.objectify.Key.create(
                                                testKey,
                                                TestRunEntity.class,
                                                deviceInfoEntity.getParent().getId());
                                    })
                            .collect(Collectors.toList());
            logger.log(Level.INFO, "testRunEntityKeyList size => " + testRunEntityKeyList.size());
        } else {
            testRunEntityKeyList = this.getTestRunEntityKeyList(testCoverageStatusEntityList);
        }
        Iterator<Key<TestRunEntity>> testRunEntityKeyIterator = testRunEntityKeyList.iterator();

        Map<Key<TestRunEntity>, TestRunEntity> keyTestRunEntityMap =
                ofy().load().keys(() -> testRunEntityKeyIterator);

        List<com.googlecode.objectify.Key<CodeCoverageEntity>> codeCoverageEntityKeyList =
                new ArrayList<>();
        Map<Long, TestRunEntity> testRunEntityMap = new HashMap<>();
        for (Map.Entry<com.googlecode.objectify.Key<TestRunEntity>, TestRunEntity> entry :
                keyTestRunEntityMap.entrySet()) {
            com.googlecode.objectify.Key codeCoverageEntityKey =
                    com.googlecode.objectify.Key.create(
                            entry.getKey(), CodeCoverageEntity.class, entry.getValue().getId());
            codeCoverageEntityKeyList.add(codeCoverageEntityKey);
            testRunEntityMap.put(entry.getValue().getId(), entry.getValue());
        }

        Map<com.googlecode.objectify.Key<CodeCoverageEntity>, CodeCoverageEntity>
                keyCodeCoverageEntityMap =
                        ofy().load().keys(() -> codeCoverageEntityKeyList.iterator());

        Map<Long, CodeCoverageEntity> codeCoverageEntityMap = new HashMap<>();
        for (Map.Entry<com.googlecode.objectify.Key<CodeCoverageEntity>, CodeCoverageEntity> entry :
                keyCodeCoverageEntityMap.entrySet()) {
            codeCoverageEntityMap.put(entry.getValue().getId(), entry.getValue());
        }

        int coveredLines = 0;
        int uncoveredLines = 0;
        int passCount = 0;
        int failCount = 0;
        for (Map.Entry<Long, CodeCoverageEntity> entry : codeCoverageEntityMap.entrySet()) {
            TestRunEntity testRunEntity = testRunEntityMap.get(entry.getKey());

            CodeCoverageEntity codeCoverageEntity = entry.getValue();

            coveredLines += codeCoverageEntity.getCoveredLineCount();
            uncoveredLines +=
                    codeCoverageEntity.getTotalLineCount()
                            - codeCoverageEntity.getCoveredLineCount();
            passCount += testRunEntity.getPassCount();
            failCount += testRunEntity.getFailCount();
        }

        FilterUtil.setAttributes(request, parameterMap);

        int[] testStats = new int[VtsReportMessage.TestCaseResult.values().length];
        testStats[VtsReportMessage.TestCaseResult.TEST_CASE_RESULT_PASS.getNumber()] = passCount;
        testStats[VtsReportMessage.TestCaseResult.TEST_CASE_RESULT_FAIL.getNumber()] = failCount;

        response.setStatus(HttpServletResponse.SC_OK);
        request.setAttribute("resultNames", resultNames);
        request.setAttribute("resultNamesJson", new Gson().toJson(resultNames));
        request.setAttribute("testRunEntityList", testRunEntityMap.values());
        request.setAttribute("codeCoverageEntityMap", codeCoverageEntityMap);
        request.setAttribute("coveredLines", new Gson().toJson(coveredLines));
        request.setAttribute("uncoveredLines", new Gson().toJson(uncoveredLines));
        request.setAttribute("testStats", new Gson().toJson(testStats));

        request.setAttribute("unfiltered", unfiltered);
        request.setAttribute("showPresubmit", showPresubmit);
        request.setAttribute("showPostsubmit", showPostsubmit);

        request.setAttribute(
                "deviceOptions",
                TestCoverageStatusEntity.getDeviceSet(testCoverageStatusEntityList));
        request.setAttribute(
                "branchOptions",
                TestCoverageStatusEntity.getBranchSet(testCoverageStatusEntityList));
        dispatcher = request.getRequestDispatcher(COVERAGE_OVERVIEW_JSP);
        return dispatcher;
    }

    private DataTable getCoverageDataTable(String testName) {

        Datastore datastore = DatastoreOptions.getDefaultInstance().getService();

        DataTable dataTable = new DataTable();
        ArrayList<ColumnDescription> cd = new ArrayList<>();
        ColumnDescription startDate =
                new ColumnDescription("startDate", ValueType.DATETIME, "Date");
        startDate.setPattern("yyyy-MM-dd");
        cd.add(startDate);
        cd.add(
                new ColumnDescription(
                        "coveredLineCount", ValueType.NUMBER, "Covered Source Code Line Count"));
        cd.add(
                new ColumnDescription(
                        "totalLineCount", ValueType.NUMBER, "Total Source Code Line Count"));
        cd.add(new ColumnDescription("percentage", ValueType.NUMBER, "Coverage Ratio (%)"));

        dataTable.addColumns(cd);

        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, -6);
        Long startTime = cal.getTime().getTime() * 1000;
        Long endTime = Calendar.getInstance().getTime().getTime() * 1000;

        com.google.cloud.datastore.Key startKey =
                datastore
                        .newKeyFactory()
                        .setKind(TestRunEntity.KIND)
                        .addAncestors(
                                PathElement.of(TestEntity.KIND, testName),
                                PathElement.of(TestRunEntity.KIND, startTime))
                        .newKey(startTime);

        com.google.cloud.datastore.Key endKey =
                datastore
                        .newKeyFactory()
                        .setKind(TestRunEntity.KIND)
                        .addAncestors(
                                PathElement.of(TestEntity.KIND, testName),
                                PathElement.of(TestRunEntity.KIND, endTime))
                        .newKey(endTime);

        Filter codeCoverageFilter =
                CompositeFilter.and(
                        PropertyFilter.lt("__key__", endKey),
                        PropertyFilter.gt("__key__", startKey));

        List<CodeCoverageEntity> codeCoverageEntityList =
                ofy().load()
                        .type(CodeCoverageEntity.class)
                        .filter(codeCoverageFilter)
                        .limit(10)
                        .list();

        DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd");
        Map<String, List<CodeCoverageEntity>> codeCoverageEntityListMap =
                codeCoverageEntityList
                        .stream()
                        .collect(
                                Collectors.groupingBy(
                                        v -> dateTimeFormatter.print(v.getId() / 1000)));

        codeCoverageEntityListMap.forEach(
                (key, entityList) -> {
                    GregorianCalendar gCal = new GregorianCalendar();
                    gCal.setTimeZone(TimeZone.getTimeZone("GMT"));
                    gCal.setTimeInMillis(entityList.get(0).getId() / 1000);

                    Long sumCoveredLine =
                            entityList.stream().mapToLong(val -> val.getCoveredLineCount()).sum();
                    Long sumTotalLine =
                            entityList.stream().mapToLong(val -> val.getTotalLineCount()).sum();
                    float percentage = 0;
                    if (sumTotalLine > 0) {
                        BigDecimal coveredLineNum = new BigDecimal(sumCoveredLine);
                        BigDecimal totalLineNum = new BigDecimal(sumTotalLine);
                        BigDecimal totalPercent = new BigDecimal(100);
                        percentage =
                                coveredLineNum
                                        .multiply(totalPercent)
                                        .divide(totalLineNum, 2, RoundingMode.HALF_DOWN)
                                        .floatValue();
                    }

                    TableRow tableRow = new TableRow();
                    tableRow.addCell(new DateTimeValue(gCal));
                    tableRow.addCell(new NumberValue(sumCoveredLine));
                    tableRow.addCell(new NumberValue(sumTotalLine));
                    tableRow.addCell(new NumberValue(percentage));
                    try {
                        dataTable.addRow(tableRow);
                    } catch (TypeMismatchException e) {
                        logger.log(Level.WARNING, "Invalid type! ");
                    }
                });

        return dataTable;
    }
}