/*
 * 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.DeviceInfoEntity;
import com.android.vts.entity.TestPlanEntity;
import com.android.vts.entity.TestPlanRunEntity;
import com.android.vts.entity.TestSuiteResultEntity;
import com.android.vts.util.DatastoreHelper;
import com.android.vts.util.FilterUtil;
import com.android.vts.util.Pagination;

import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;
import com.google.appengine.api.datastore.Query;
import com.google.appengine.api.datastore.Query.Filter;
import com.google.appengine.api.datastore.Query.SortDirection;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import org.apache.commons.lang.StringUtils;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.logging.Level;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

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

public class ShowPlanReleaseServlet extends BaseServlet {
    private static final int MAX_RUNS_PER_PAGE = 90;

    /** the previous cursor string token list where to start */
    private static final LinkedHashSet<String> pageCountTokenSet = new LinkedHashSet<>();

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

    @Override
    public List<Page> getBreadcrumbLinks(HttpServletRequest request) {
        String testType =
                request.getParameter("type") == null ? "plan" : request.getParameter("type");
        List<Page> links = new ArrayList<>();
        String planName = request.getParameter("plan");
        if (testType.equals("plan")) {
            links.add(new Page(PageType.RELEASE, "TEST PLANS", "?type=" + testType, true));
            links.add(new Page(PageType.PLAN_RELEASE, planName, "?plan=" + planName));
        } else {
            links.add(new Page(PageType.RELEASE, "TEST SUITES", "?type=" + testType, true));
            links.add(
                    new Page(
                            PageType.PLAN_RELEASE,
                            planName,
                            "?plan=" + planName + "&type=" + testType));
        }
        return links;
    }

    /** Model to describe each test plan run . */
    private class TestPlanRunMetadata implements Comparable<TestPlanRunMetadata> {
        public final TestPlanRunEntity testPlanRun;
        public final List<String> devices;
        public final Set<DeviceInfoEntity> deviceSet;

        public TestPlanRunMetadata(TestPlanRunEntity testPlanRun) {
            this.testPlanRun = testPlanRun;
            this.devices = new ArrayList<>();
            this.deviceSet = new HashSet<>();
        }

        public void addDevice(DeviceInfoEntity device) {
            if (device == null || deviceSet.contains(device)) return;
            devices.add(
                    device.getBranch()
                            + "/"
                            + device.getBuildFlavor()
                            + " ("
                            + device.getBuildId()
                            + ")");
            deviceSet.add(device);
        }

        public JsonObject toJson() {
            JsonObject obj = new JsonObject();
            obj.add("testPlanRun", testPlanRun.toJson());
            obj.add("deviceInfo", new JsonPrimitive(StringUtils.join(devices, ", ")));
            return obj;
        }

        @Override
        public int compareTo(TestPlanRunMetadata o) {
            return new Long(o.testPlanRun.getStartTimestamp())
                    .compareTo(this.testPlanRun.getStartTimestamp());
        }
    }

    @Override
    public void doGetHandler(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        String testType =
                request.getParameter("type") == null ? "plan" : request.getParameter("type");

        RequestDispatcher dispatcher;
        if (testType.equalsIgnoreCase("plan")) {
            dispatcher = this.getTestPlanDispatcher(request, response);
        } else {
            dispatcher = this.getTestSuiteDispatcher(request, response);
        }

        try {
            request.setAttribute("testType", testType);
            response.setStatus(HttpServletResponse.SC_OK);
            dispatcher.forward(request, response);
        } catch (ServletException e) {
            logger.log(Level.SEVERE, "Servlet Excpetion caught : ", e);
        }
    }

    private RequestDispatcher getTestPlanDispatcher(
            HttpServletRequest request, HttpServletResponse response) {
        String PLAN_RELEASE_JSP = "WEB-INF/jsp/show_plan_release.jsp";

        DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();

        Long startTime = null; // time in microseconds
        Long endTime = null; // time in microseconds
        if (request.getParameter("startTime") != null) {
            String time = request.getParameter("startTime");
            try {
                startTime = Long.parseLong(time);
                startTime = startTime > 0 ? startTime : null;
            } catch (NumberFormatException e) {
                startTime = null;
            }
        }
        if (request.getParameter("endTime") != null) {
            String time = request.getParameter("endTime");
            try {
                endTime = Long.parseLong(time);
                endTime = endTime > 0 ? endTime : null;
            } catch (NumberFormatException e) {
                endTime = null;
            }
        }
        SortDirection dir = SortDirection.DESCENDING;
        if (startTime != null && endTime == null) {
            dir = SortDirection.ASCENDING;
        }
        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;
        }
        Filter typeFilter = FilterUtil.getTestTypeFilter(showPresubmit, showPostsubmit, unfiltered);
        String testPlan = request.getParameter("plan");
        Key testPlanKey = KeyFactory.createKey(TestPlanEntity.KIND, testPlan);
        Filter testPlanRunFilter =
                FilterUtil.getTimeFilter(
                        testPlanKey, TestPlanRunEntity.KIND, startTime, endTime, typeFilter);
        Map<String, String[]> parameterMap = request.getParameterMap();
        List<Filter> userTestFilters = FilterUtil.getUserTestFilters(parameterMap);
        userTestFilters.add(0, testPlanRunFilter);
        Filter userDeviceFilter = FilterUtil.getUserDeviceFilter(parameterMap);

        List<TestPlanRunMetadata> testPlanRuns = new ArrayList<>();
        Map<Key, TestPlanRunMetadata> testPlanMap = new HashMap<>();
        Key minKey = null;
        Key maxKey = null;
        List<Key> gets =
                FilterUtil.getMatchingKeys(
                        testPlanKey,
                        TestPlanRunEntity.KIND,
                        userTestFilters,
                        userDeviceFilter,
                        dir,
                        MAX_RUNS_PER_PAGE);
        Map<Key, Entity> entityMap = datastore.get(gets);
        logger.log(Level.INFO, "entityMap => " + entityMap);
        for (Key key : gets) {
            if (!entityMap.containsKey(key)) {
                continue;
            }
            TestPlanRunEntity testPlanRun = TestPlanRunEntity.fromEntity(entityMap.get(key));
            if (testPlanRun == null) {
                continue;
            }
            TestPlanRunMetadata metadata = new TestPlanRunMetadata(testPlanRun);
            testPlanRuns.add(metadata);
            testPlanMap.put(key, metadata);
            if (minKey == null || key.compareTo(minKey) < 0) {
                minKey = key;
            }
            if (maxKey == null || key.compareTo(maxKey) > 0) {
                maxKey = key;
            }
        }
        if (minKey != null && maxKey != null) {
            Filter deviceFilter =
                    FilterUtil.getDeviceTimeFilter(
                            testPlanKey, TestPlanRunEntity.KIND, minKey.getId(), maxKey.getId());
            Query deviceQuery =
                    new Query(DeviceInfoEntity.KIND)
                            .setAncestor(testPlanKey)
                            .setFilter(deviceFilter)
                            .setKeysOnly();
            List<Key> deviceGets = new ArrayList<>();
            for (Entity device :
                    datastore
                            .prepare(deviceQuery)
                            .asIterable(DatastoreHelper.getLargeBatchOptions())) {
                if (testPlanMap.containsKey(device.getParent())) {
                    deviceGets.add(device.getKey());
                }
            }
            logger.log(Level.INFO, "deviceGets => " + deviceGets);
            Map<Key, Entity> devices = datastore.get(deviceGets);
            for (Key key : devices.keySet()) {
                if (!testPlanMap.containsKey(key.getParent())) continue;
                DeviceInfoEntity device = DeviceInfoEntity.fromEntity(devices.get(key));
                if (device == null) continue;
                TestPlanRunMetadata metadata = testPlanMap.get(key.getParent());
                metadata.addDevice(device);
            }
        }

        testPlanRuns.sort(Comparator.naturalOrder());
        logger.log(Level.INFO, "testPlanRuns => " + testPlanRuns);

        if (testPlanRuns.size() > 0) {
            TestPlanRunMetadata firstRun = testPlanRuns.get(0);
            endTime = firstRun.testPlanRun.getStartTimestamp();

            TestPlanRunMetadata lastRun = testPlanRuns.get(testPlanRuns.size() - 1);
            startTime = lastRun.testPlanRun.getStartTimestamp();
        }

        List<JsonObject> testPlanRunObjects = new ArrayList<>();
        for (TestPlanRunMetadata metadata : testPlanRuns) {
            testPlanRunObjects.add(metadata.toJson());
        }

        FilterUtil.setAttributes(request, parameterMap);

        request.setAttribute("plan", request.getParameter("plan"));
        request.setAttribute(
                "hasNewer",
                new Gson()
                        .toJson(
                                DatastoreHelper.hasNewer(
                                        testPlanKey, TestPlanRunEntity.KIND, endTime)));
        request.setAttribute(
                "hasOlder",
                new Gson()
                        .toJson(
                                DatastoreHelper.hasOlder(
                                        testPlanKey, TestPlanRunEntity.KIND, startTime)));
        request.setAttribute("planRuns", new Gson().toJson(testPlanRunObjects));

        request.setAttribute("unfiltered", unfiltered);
        request.setAttribute("showPresubmit", showPresubmit);
        request.setAttribute("showPostsubmit", showPostsubmit);
        request.setAttribute("startTime", new Gson().toJson(startTime));
        request.setAttribute("endTime", new Gson().toJson(endTime));
        request.setAttribute("branches", new Gson().toJson(DatastoreHelper.getAllBranches()));
        request.setAttribute("devices", new Gson().toJson(DatastoreHelper.getAllBuildFlavors()));

        RequestDispatcher dispatcher = request.getRequestDispatcher(PLAN_RELEASE_JSP);
        return dispatcher;
    }

    private RequestDispatcher getTestSuiteDispatcher(
            HttpServletRequest request, HttpServletResponse response) {
        String PLAN_RELEASE_JSP = "WEB-INF/jsp/show_suite_release.jsp";

        String testPlan = request.getParameter("plan");
        String testCategoryType =
                Objects.isNull(request.getParameter("testCategoryType"))
                        ? "1"
                        : request.getParameter("testCategoryType");
        int page =
                Objects.isNull(request.getParameter("page"))
                        ? 1
                        : Integer.valueOf(request.getParameter("page"));
        String nextPageToken =
                Objects.isNull(request.getParameter("nextPageToken"))
                        ? ""
                        : request.getParameter("nextPageToken");

        com.googlecode.objectify.cmd.Query<TestSuiteResultEntity> testSuiteResultEntityQuery =
                ofy().load()
                        .type(TestSuiteResultEntity.class)
                        .filter("suitePlan", testPlan)
                        .filter(this.getTestTypeFieldName(testCategoryType), true);

        if (Objects.nonNull(request.getParameter("branch"))) {
            request.setAttribute("branch", request.getParameter("branch"));
            testSuiteResultEntityQuery =
                    testSuiteResultEntityQuery.filter("branch", request.getParameter("branch"));
        }
        if (Objects.nonNull(request.getParameter("hostName"))) {
            request.setAttribute("hostName", request.getParameter("hostName"));
            testSuiteResultEntityQuery =
                    testSuiteResultEntityQuery.filter("hostName", request.getParameter("hostName"));
        }
        if (Objects.nonNull(request.getParameter("buildId"))) {
            request.setAttribute("buildId", request.getParameter("buildId"));
            testSuiteResultEntityQuery =
                    testSuiteResultEntityQuery.filter("buildId", request.getParameter("buildId"));
        }
        if (Objects.nonNull(request.getParameter("deviceName"))) {
            request.setAttribute("deviceName", request.getParameter("deviceName"));
            testSuiteResultEntityQuery =
                    testSuiteResultEntityQuery.filter(
                            "deviceName", request.getParameter("deviceName"));
        }
        testSuiteResultEntityQuery = testSuiteResultEntityQuery.orderKey(true);

        Pagination<TestSuiteResultEntity> testSuiteResultEntityPagination =
                new Pagination(
                        testSuiteResultEntityQuery,
                        page,
                        Pagination.DEFAULT_PAGE_SIZE,
                        nextPageToken,
                        pageCountTokenSet);

        String nextPageTokenPagination = testSuiteResultEntityPagination.getNextPageCountToken();
        if (!nextPageTokenPagination.trim().isEmpty()) {
            this.pageCountTokenSet.add(nextPageTokenPagination);
        }

        logger.log(Level.INFO, "pageCountTokenSet => " + pageCountTokenSet);

        logger.log(Level.INFO, "list => " + testSuiteResultEntityPagination.getList());
        logger.log(
                Level.INFO,
                "next page count token => "
                        + testSuiteResultEntityPagination.getNextPageCountToken());
        logger.log(
                Level.INFO,
                "page min range => " + testSuiteResultEntityPagination.getMinPageRange());
        logger.log(
                Level.INFO,
                "page max range => " + testSuiteResultEntityPagination.getMaxPageRange());
        logger.log(Level.INFO, "page size => " + testSuiteResultEntityPagination.getPageSize());
        logger.log(Level.INFO, "total count => " + testSuiteResultEntityPagination.getTotalCount());

        request.setAttribute("plan", testPlan);
        request.setAttribute("page", page);
        request.setAttribute("testType", "suite");
        request.setAttribute("testCategoryType", testCategoryType);
        request.setAttribute("testSuiteResultEntityPagination", testSuiteResultEntityPagination);
        RequestDispatcher dispatcher = request.getRequestDispatcher(PLAN_RELEASE_JSP);
        return dispatcher;
    }

    private String getTestTypeFieldName(String testCategoryType) {
        String fieldName;
        switch (testCategoryType) {
            case "1": // TOT
                fieldName = "testTypeIndex.TOT";
                break;
            case "2": // OTA
                fieldName = "testTypeIndex.OTA";
                break;
            case "4": // SIGNED
                fieldName = "testTypeIndex.SIGNED";
                break;
            default:
                fieldName = "testTypeIndex.TOT";
                break;
        }
        return fieldName;
    }
}