/*-------------------------------------------------------------------------+
|                                                                          |
| Copyright 2005-2011 the ConQAT Project                                   |
|                                                                          |
| 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 org.conqat.engine.sourcecode.coverage;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.IntStream;

import org.conqat.lib.commons.assertion.CCSMAssert;
import org.conqat.lib.commons.collections.CollectionUtils;
import org.conqat.lib.commons.js_export.ExportToJavaScript;
import org.conqat.lib.commons.string.StringUtils;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.thoughtworks.xstream.annotations.XStreamAlias;

import eu.cqse.check.framework.scanner.ETokenType.ETokenClass;
import eu.cqse.check.framework.scanner.IToken;
import eu.cqse.check.framework.shallowparser.framework.ShallowEntity;

/**
 * Holds line coverage information for a file.
 */
@ExportToJavaScript
public class LineCoverageInfo implements Serializable {

        /** Version for serialization. */
        private static final long serialVersionUID = 1L;

        /** The name of the JSON property name for {@link #timestamp}. */
        private static final String TIMESTAMP_PROPERTY = "timestamp";

        /** The name of the JSON property name for {@link #isMethodAccurate}. */
        private static final String IS_METHOD_ACCURATE_PROPERTY = "isMethodAccurate";

        /** The line numbers that were fully covered */
        @JsonProperty("fullyCoveredLines")
        @XStreamAlias("fully-covered-lines")
        private final Set<Integer> fullyCoveredLines = new HashSet<>();

        /** The line numbers that were partially covered */
        @JsonProperty("partiallyCoveredLines")
        @XStreamAlias("partially-covered-lines")
        private final Set<Integer> partiallyCoveredLines = new HashSet<>();

        /** The line numbers that were not covered */
        @JsonProperty("uncoveredLines")
        @XStreamAlias("uncovered-lines")
        private final Set<Integer> uncoveredLines = new HashSet<>();

        /**
         * Determines the accuracy of this coverage info. If <code>false</code>, the
         * info is line-accurate, otherwise it is only method-accurate (i.e. executing
         * any statement in the method will mark the entire method as executed). The
         * default is line-accurate.
         * 
         * Note that method-accurate coverage should not be used when e.g. calculating
         * the line coverage metric.
         */
        @JsonProperty(IS_METHOD_ACCURATE_PROPERTY)
        private boolean isMethodAccurate = false;

        /**
         * @see #isMethodAccurate
         */
        public boolean isMethodAccurate() {
                return isMethodAccurate;
        }

        /**
         * @see #isMethodAccurate
         */
        public void setMethodAccurate(boolean isMethodAccurate) {
                this.isMethodAccurate = isMethodAccurate;
        }

        /**
         * The timestamp of the code this coverage data refers to. May be -1 if unknown.
         */
        @JsonProperty(TIMESTAMP_PROPERTY)
        private long timestamp;

        /** Constructor with a default timestamp. */
        public LineCoverageInfo(boolean isMethodAccurate) {
                this(-1, isMethodAccurate);
        }

        /** Constructor */
        @JsonCreator
        public LineCoverageInfo(@JsonProperty(TIMESTAMP_PROPERTY) long timestamp,
                        @JsonProperty(IS_METHOD_ACCURATE_PROPERTY) boolean isMethodAccurate) {
                this.timestamp = timestamp;
                this.isMethodAccurate = isMethodAccurate;
        }

        /**
         * Adds the coverage information for the given line. This merges the given
         * coverage info if called multiple times for the same line. This is needed to
         * allow for overlapping coverage reports.
         */
        public void addLineCoverage(int line, ELineCoverage coverage) {
                CCSMAssert.isNotNull(coverage);

                ELineCoverage existingCoverage = getLineCoverage(line);
                if (existingCoverage == null) {
                        setLineCoverage(line, coverage);
                        return;
                }

                switch (existingCoverage) {
                case NOT_COVERED:
                        uncoveredLines.remove(line);
                        setLineCoverage(line, coverage);
                        break;
                case PARTIALLY_COVERED:
                        if (coverage.equals(ELineCoverage.FULLY_COVERED)) {
                                partiallyCoveredLines.remove(line);
                                fullyCoveredLines.add(line);
                        }
                        break;
                case FULLY_COVERED:
                        // cannot get any better
                        break;
                default:
                        throw new IllegalStateException("Unknown line coverage: " + coverage);
                }

        }

        /**
         * Adds the coverage information for the given lines.
         * 
         * @see #addLineCoverage(int, ELineCoverage)
         */
        public void addLineCoverage(Collection<Integer> lines, ELineCoverage coverage) {
                for (Integer line : lines) {
                        addLineCoverage(line, coverage);
                }
        }

        /**
         * Adds the coverage information for the given lines.
         * 
         * @see #addLineCoverage(int, ELineCoverage)
         */
        public void addLineCoverage(IntStream lines, ELineCoverage coverage) {
                lines.forEach(line -> addLineCoverage(line, coverage));
        }

        /** Removes all previously stored line coverage for the given line. */
        public void removeLineCoverageInfo(int line) {
                fullyCoveredLines.remove(line);
                partiallyCoveredLines.remove(line);
                uncoveredLines.remove(line);
        }

        /**
         * Sets the line coverage for the given line. This ignores previously stored
         * values.
         */
        private void setLineCoverage(int line, ELineCoverage coverage) {
                switch (coverage) {
                case FULLY_COVERED:
                        fullyCoveredLines.add(line);
                        break;
                case PARTIALLY_COVERED:
                        partiallyCoveredLines.add(line);
                        break;
                case NOT_COVERED:
                        uncoveredLines.add(line);
                        break;
                default:
                        throw new IllegalStateException("Unknown line coverage: " + coverage);
                }
        }

        /** Adds all coverage information from another {@link LineCoverageInfo}. */
        public void addAll(LineCoverageInfo coverageInfo) {
                for (int line : coverageInfo.fullyCoveredLines) {
                        addLineCoverage(line, ELineCoverage.FULLY_COVERED);
                }
                for (int line : coverageInfo.partiallyCoveredLines) {
                        addLineCoverage(line, ELineCoverage.PARTIALLY_COVERED);
                }
                for (int line : coverageInfo.uncoveredLines) {
                        addLineCoverage(line, ELineCoverage.NOT_COVERED);
                }
        }

        /**
         * Returns the line coverage for the given line or <code>null</code> if none is
         * stored.
         */
        public ELineCoverage getLineCoverage(int line) {
                if (fullyCoveredLines.contains(line)) {
                        return ELineCoverage.FULLY_COVERED;
                }
                if (partiallyCoveredLines.contains(line)) {
                        return ELineCoverage.PARTIALLY_COVERED;
                }
                if (uncoveredLines.contains(line)) {
                        return ELineCoverage.NOT_COVERED;
                }
                return null;
        }

        /** Returns list of fully covered lines (sorted ascending) */
        public List<Integer> getFullyCoveredLines() {
                return CollectionUtils.sort(fullyCoveredLines);
        }

        /** Returns list of partially covered lines (sorted ascending) */
        public List<Integer> getPartiallyCoveredLines() {
                return CollectionUtils.sort(partiallyCoveredLines);
        }

        /** Returns list of uncovered lines (sorted ascending) */
        public List<Integer> getUncoveredLines() {
                return CollectionUtils.sort(uncoveredLines);
        }

        /** Returns the line coverage ratio as a double ([0..1]). */
        public double getCoverageRatio() {
                int lines = getCoverableLines();
                if (lines == 0) {
                        return 0;
                }
                return getCoveredLines() / lines;
        }

        /** Returns the number of lines that are covered or partially covered. */
        public double getCoveredLines() {
                return fullyCoveredLines.size() + partiallyCoveredLines.size();
        }

        /** Returns the number of lines that are coverable. */
        public int getCoverableLines() {
                return fullyCoveredLines.size() + partiallyCoveredLines.size() + uncoveredLines.size();
        }

        /** Returns the set of all lines in the coverage report. */
        public Set<Integer> getAllCoverableLines() {
                return CollectionUtils.unionSet(fullyCoveredLines, partiallyCoveredLines, uncoveredLines);
        }

        /**
         * @see #timestamp
         */
        public long getTimestamp() {
                return timestamp;
        }

        /**
         * @see #timestamp
         */
        public void setTimestamp(long timestamp) {
                this.timestamp = timestamp;
        }

        /** {@inheritDoc} */
        @Override
        public String toString() {
                return String.valueOf(getCoverageRatio());
        }

        /** Returns a string representation of the covered/uncovered lines. */
        public String toLineString() {
                return "Fully covered: " + StringUtils.concat(CollectionUtils.sort(fullyCoveredLines), ",")
                                + "; partially covered: " + StringUtils.concat(CollectionUtils.sort(partiallyCoveredLines), ",")
                                + "; uncovered: " + StringUtils.concat(CollectionUtils.sort(uncoveredLines), ",") + "; timestamp: "
                                + timestamp;
        }

        /**
         * Replaces the coverable lines with the given lines. This also adjusts the
         * {@link #fullyCoveredLines} and {@link #partiallyCoveredLines} by removing all
         * lines that are not coverable.
         */
        public void setCoverableLines(Set<Integer> lines) {
                fullyCoveredLines.retainAll(lines);
                partiallyCoveredLines.retainAll(lines);

                uncoveredLines.clear();
                uncoveredLines.addAll(lines);
                uncoveredLines.removeAll(fullyCoveredLines);
                uncoveredLines.removeAll(partiallyCoveredLines);
        }

        /**
         * Creates a copy of this object that is stable in regards to serialization, as
         * it creates the {@link #fullyCoveredLines}, {@link #partiallyCoveredLines} and
         * {@link #uncoveredLines} sets by adding the respective entries in a sorted
         * manner.
         * 
         * This is somewhat of a hack,as this relies on java sets always turning out the
         * same, if the entries are inserted in the same order.
         */
        public LineCoverageInfo createStableCopy() {
                LineCoverageInfo copy = new LineCoverageInfo(this.isMethodAccurate);
                copy.addLineCoverage(getFullyCoveredLines(), ELineCoverage.FULLY_COVERED);
                copy.addLineCoverage(getPartiallyCoveredLines(), ELineCoverage.PARTIALLY_COVERED);
                copy.addLineCoverage(getUncoveredLines(), ELineCoverage.NOT_COVERED);
                return copy;
        }

        /**
         * Extends coverage to full entities by using the best covered line for all
         * lines of an entity.
         */
        public void extendCoverageToStatements(Collection<ShallowEntity> coverableEntities) {
                for (ShallowEntity entity : coverableEntities) {
                        List<IToken> ownStartTokens = CollectionUtils.filter(entity.ownStartTokens(),
                                        token -> token.getType().getTokenClass() != ETokenClass.SYNTHETIC);
                        if (ownStartTokens.isEmpty()) {
                                continue;
                        }

                        int startLine = ownStartTokens.get(0).getLineNumber() + 1;
                        int endLine = CollectionUtils.getLast(ownStartTokens).getLineNumber() + 1;
                        if (startLine == endLine) {
                                // no adjustment needed for single line entities
                                continue;
                        }

                        if (IntStream.range(startLine, endLine + 1).anyMatch(fullyCoveredLines::contains)) {
                                IntStream.range(startLine, endLine + 1).forEach(fullyCoveredLines::add);
                                IntStream.range(startLine, endLine + 1).forEach(partiallyCoveredLines::remove);
                                IntStream.range(startLine, endLine + 1).forEach(uncoveredLines::remove);
                        } else if (IntStream.range(startLine, endLine + 1).anyMatch(partiallyCoveredLines::contains)) {
                                IntStream.range(startLine, endLine + 1).forEach(partiallyCoveredLines::add);
                                IntStream.range(startLine, endLine + 1).forEach(uncoveredLines::remove);
                        }
                }
        }
}