/*
 * Copyright (c) 2010-2012 Grid Dynamics Consulting Services, Inc, All Rights Reserved
 * http://www.griddynamics.com
 *
 * This library is free software; you can redistribute it and/or modify it under the terms of
 * the Apache License; either
 * version 2.0 of the License, or any later version.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.griddynamics.jagger.engine.e1.scenario;

import com.griddynamics.jagger.coordinator.NodeId;

import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;

import java.util.Map;
import java.util.Set;

public class WorkloadExecutionStatusBuilder {
    private final Map<NodeId, Integer> threads = Maps.newConcurrentMap();
    private final Map<NodeId, Integer> startedSamples = Maps.newConcurrentMap();
    private final Map<NodeId, Integer> finishedSamples = Maps.newConcurrentMap();
    private final Map<NodeId, Long> emptyTransactions = Maps.newConcurrentMap();
    private final Map<NodeId, Integer> delays = Maps.newConcurrentMap();
    private final Map<NodeId, Long> pollTime = Maps.newConcurrentMap();
    private final Map<NodeId, Long> durationTime = Maps.newConcurrentMap();
    private WorkloadTask task;

    public WorkloadExecutionStatusBuilder(WorkloadTask task) {
        this.task = task;
    }

    public WorkloadExecutionStatusBuilder addNodeInfo(NodeId id, int threads, int startedSamples, int finishedSamples, long emptyTransactions, Integer delay, long pollTime, long durationTime) {
        this.threads.put(id, threads);
        this.startedSamples.put(id, startedSamples);
        this.finishedSamples.put(id, finishedSamples);
        this.emptyTransactions.put(id, emptyTransactions);
        this.delays.put(id, delay);
        this.pollTime.put(id, pollTime);
        this.durationTime.put(id, durationTime);
        return this;
    }

    public WorkloadExecutionStatus build() {
        return new DefaultWorkloadExecutionStatus(threads, startedSamples, finishedSamples, emptyTransactions, delays, pollTime, durationTime, task);
    }

    private class DefaultWorkloadExecutionStatus implements WorkloadExecutionStatus {
        private final Set<NodeId> nodes;
        private final Map<NodeId, Integer> threads;
        private final Map<NodeId, Integer> startedSamples;
        private final Map<NodeId, Integer> finishedSamples;
        private final Map<NodeId, Long> emptyTransactions;
        private final Map<NodeId, Integer> delays;
        private final Map<NodeId, Long> pollTime;
        private final Map<NodeId, Long> durationTime;
        private WorkloadTask task;

        private DefaultWorkloadExecutionStatus(Map<NodeId, Integer> threads,
                                               Map<NodeId, Integer> startedSamples,
                                               Map<NodeId, Integer> finishedSamples,
                                               Map<NodeId, Long> emptyTransactions,
                                               Map<NodeId, Integer> delays,
                                               Map<NodeId, Long> pollTime,
                                               Map<NodeId, Long> durationTime,
                                               WorkloadTask task) {
            boolean nodesAreEqual = threads.keySet().equals(startedSamples.keySet()) && startedSamples.keySet().equals(pollTime.keySet());

            Preconditions.checkArgument(nodesAreEqual);
            this.nodes = threads.keySet();

            this.task = task;
            this.threads = threads;
            this.startedSamples = startedSamples;
            this.finishedSamples = finishedSamples;
            this.emptyTransactions = emptyTransactions;
            this.delays = delays;
            this.pollTime = pollTime;
            this.durationTime = durationTime;
        }

        @Override
        public Set<NodeId> getNodes() {
            return nodes;
        }

        @Override
        public Integer getThreads(NodeId id) {
            return threads.get(id);
        }

        @Override
        public Integer getStartedSamples(NodeId id) {
            return startedSamples.get(id);
        }

        @Override
        public Integer getSamples(NodeId id) {
            return finishedSamples.get(id);
        }

        @Override
        public Integer getDelay(NodeId id) {
            return delays.get(id);
        }

        @Override
        public Long getPollTime(NodeId id) {
            return pollTime.get(id);
        }
    
        @Override
        public long getEmptyTransactions(NodeId id) {
            return emptyTransactions.get(id);
        }
    
        @Override
        public int getTotalStartedSamples() {
            int result = 0;
            for (Integer sample : startedSamples.values()) {
                result += sample;
            }
            return result;
        }

        @Override
        public int getTotalSamples() {
            int result = 0;
            for (Integer sample : finishedSamples.values()) {
                result += sample;
            }
            return result;
        }

        @Override
        public int getTotalThreads() {
            int result = 0;
            for (Integer threads : this.threads.values()) {
                result += threads;
            }
            return result;
        }

        @Override
        public String toString() {
            String line = "---------------------------------------------------------------------------------------------------------------------------------------------------\n";
            String format = "|%1$-40s|%2$-20s|%3$-20s|%4$-20s|%5$-20s|%6$-20s|\n";
            String report = String.format(this.task.getTaskName() + '\n' +
                    line + format + line, "IDENTIFIER", "THREADS", "STARTED", "SAMPLES", "DELAYS", "DURATION,s");
            Set<NodeId> nodes = Sets.newHashSet(this.threads.keySet());
            nodes.addAll(this.startedSamples.keySet());
            nodes.addAll(this.delays.keySet());

            for (NodeId node : nodes) {
                report += String.format(format,
                        node.getIdentifier(), this.threads.get(node),
                        this.startedSamples.get(node),
                        this.finishedSamples.get(node), this.delays.get(node), this.durationTime.get(node)/1000);
            }
            return report + line;
        }
    }
}