/*
 * Cobertura - http://cobertura.sourceforge.net/
 *
 * Copyright (C) 2003 jcoverage ltd.
 * Copyright (C) 2005 Mark Doliner
 * Copyright (C) 2005 Mark Sinke
 * Copyright (C) 2006 Jiri Mares
 *
 * Cobertura is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * Cobertura is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Cobertura; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */

package net.sourceforge.cobertura.coveragedata;

import net.sourceforge.cobertura.CoverageIgnore;
import net.sourceforge.cobertura.util.StringUtil;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

@CoverageIgnore
public class LineData implements Comparable<Object>, CoverageData, Serializable {
	private static final long serialVersionUID = 4;

	private long hits;
	private List<JumpData> jumps;
	private List<SwitchData> switches;
	private final int lineNumber;
	private String methodDescriptor;
	private String methodName;

	LineData(int lineNumber) {
		this(lineNumber, null, null);
	}

	LineData(int lineNumber, String methodName, String methodDescriptor) {
		this.hits = 0;
		this.jumps = null;
		this.lineNumber = lineNumber;
		this.methodName = methodName;
		this.methodDescriptor = methodDescriptor;
	}

	
This is required because we implement Comparable.
/**
	 * This is required because we implement Comparable.
	 */
	public int compareTo(Object o) {
		if (!o.getClass().equals(LineData.class))
			return Integer.MAX_VALUE;
		return this.lineNumber - ((LineData) o).lineNumber;
	}

	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if ((obj == null) || !(obj.getClass().equals(this.getClass())))
			return false;

		LineData lineData = (LineData) obj;
		return (this.hits == lineData.hits)
				&& ((this.jumps == lineData.jumps) || ((this.jumps != null) && (this.jumps
						.equals(lineData.jumps))))
				&& ((this.switches == lineData.switches) || ((this.switches != null) && (this.switches
						.equals(lineData.switches))))
				&& (this.lineNumber == lineData.lineNumber)
				&& (this.methodDescriptor.equals(lineData.methodDescriptor))
				&& (this.methodName.equals(lineData.methodName));
	}

	public double getBranchCoverageRate() {
		if (getNumberOfValidBranches() == 0)
			return 1d;
		return ((double) getNumberOfCoveredBranches())
				/ getNumberOfValidBranches();
	}

	public String getConditionCoverage() {
		StringBuffer ret = new StringBuffer();
		if (getNumberOfValidBranches() == 0) {
			ret.append(StringUtil.getPercentValue(1.0));
		} else {
			ret.append(StringUtil.getPercentValue(getBranchCoverageRate()));
			ret.append(" (").append(getNumberOfCoveredBranches()).append("/")
					.append(getNumberOfValidBranches()).append(")");
		}
		return ret.toString();
	}

	public long getHits() {
		return hits;
	}

	synchronized public boolean isCovered() {
		return (getHits() > 0)
				&& ((getNumberOfValidBranches() == 0) || ((1.0 - getBranchCoverageRate()) < 0.0001));
	}

	public double getLineCoverageRate() {
		return (getHits() > 0) ? 1 : 0;
	}

	public int getLineNumber() {
		return lineNumber;
	}

	public String getMethodDescriptor() {
		return methodDescriptor;
	}

	public String getMethodName() {
		return methodName;
	}

	public int getNumberOfCoveredLines() {
		return (getHits() > 0) ? 1 : 0;
	}

	public int getNumberOfValidBranches() {
		int ret = 0;
		if (jumps != null)
			for (int i = jumps.size() - 1; i >= 0; i--)
				ret += ((JumpData) jumps.get(i)).getNumberOfValidBranches();
		if (switches != null)
			for (int i = switches.size() - 1; i >= 0; i--)
				ret += ((SwitchData) switches.get(i))
						.getNumberOfValidBranches();
		return ret;
	}

	public int getNumberOfCoveredBranches() {
		int ret = 0;
		if (jumps != null)
			for (int i = jumps.size() - 1; i >= 0; i--)
				ret += ((JumpData) jumps.get(i)).getNumberOfCoveredBranches();
		if (switches != null)
			for (int i = switches.size() - 1; i >= 0; i--)
				ret += ((SwitchData) switches.get(i))
						.getNumberOfCoveredBranches();
		return ret;
	}

	public int getNumberOfValidLines() {
		return 1;
	}

	public int hashCode() {
		return this.lineNumber;
	}

	public boolean hasBranch() {
		return (jumps != null) || (switches != null);
	}

	synchronized public void merge(CoverageData coverageData) {
		LineData lineData = (LineData) coverageData;
		this.hits += lineData.hits;
		if (lineData.jumps != null)
			if (this.jumps == null)
				this.jumps = lineData.jumps;
			else {
				for (int i = Math.min(this.jumps.size(), lineData.jumps.size()) - 1; i >= 0; i--)
					((JumpData) this.jumps.get(i))
							.merge((JumpData) lineData.jumps.get(i));
				for (int i = Math.min(this.jumps.size(), lineData.jumps.size()); i < lineData.jumps
						.size(); i++)
					this.jumps.add(lineData.jumps.get(i));
			}
		if (lineData.switches != null)
			if (this.switches == null)
				this.switches = lineData.switches;
			else {
				for (int i = Math.min(this.switches.size(), lineData.switches
						.size()) - 1; i >= 0; i--)
					((SwitchData) this.switches.get(i))
							.merge((SwitchData) lineData.switches.get(i));
				for (int i = Math.min(this.switches.size(), lineData.switches
						.size()); i < lineData.switches.size(); i++)
					this.switches.add(lineData.switches.get(i));
			}
		if (lineData.methodName != null)
			this.methodName = lineData.methodName;
		if (lineData.methodDescriptor != null)
			this.methodDescriptor = lineData.methodDescriptor;
	}

	void addJump(int jumpNumber) {
		getJumpData(jumpNumber);
	}

	void addSwitch(int switchNumber, int min, int max, int maxBranches) {
		SwitchData sd = getSwitchData(switchNumber, new SwitchData(
				switchNumber, min, max, maxBranches));
		if (sd.getMaxBranches() > maxBranches) {
			sd.setMaxBranches(maxBranches);
		}
	}

	void setMethodNameAndDescriptor(String name, String descriptor) {
		this.methodName = name;
		this.methodDescriptor = descriptor;
	}

	void touch(int new_hits) {
		this.hits += new_hits;
	}

	void touchJump(int jumpNumber, boolean branch, int hits) {
		getJumpData(jumpNumber).touchBranch(branch, hits);
	}

	void touchSwitch(int switchNumber, int branch, int hits) {
		getSwitchData(switchNumber, null).touchBranch(branch, hits);
	}

	public int getConditionSize() {
		return ((jumps == null) ? 0 : jumps.size())
				+ ((switches == null) ? 0 : switches.size());
	}

	public Object getConditionData(int index) {
		Object branchData = null;
		int jumpsSize = (jumps == null) ? 0 : jumps.size();
		int switchesSize = (switches == null) ? 0 : switches.size();
		if (index < jumpsSize) {
			branchData = jumps.get(index);
		} else if (index < jumpsSize + switchesSize) {
			branchData = switches.get(index - jumpsSize);
		}
		return branchData;
	}

	public String getConditionCoverage(int index) {
		Object branchData = getConditionData(index);
		if (branchData == null) {
			return StringUtil.getPercentValue(1.0);
		} else if (branchData instanceof JumpData) {
			JumpData jumpData = (JumpData) branchData;
			return StringUtil.getPercentValue(jumpData.getBranchCoverageRate());
		} else {
			SwitchData switchData = (SwitchData) branchData;
			return StringUtil.getPercentValue(switchData
					.getBranchCoverageRate());

		}
	}

	synchronized JumpData getJumpData(int jumpNumber) {
		if (jumps == null) {
			jumps = new ArrayList<JumpData>();
		}
		if (jumps.size() <= jumpNumber) {
			for (int i = jumps.size(); i <= jumpNumber; jumps.add(new JumpData(
					i++)));
		}
		return jumps.get(jumpNumber);
	}

	synchronized SwitchData getSwitchData(int switchNumber, SwitchData data) {
		if (switches == null) {
			switches = new ArrayList<SwitchData>();
		}
		if (switches.size() < switchNumber) {
			for (int i = switches.size(); i < switchNumber; switches
					.add(new SwitchData(i++, Integer.MAX_VALUE)));
		}
		if (switches.size() == switchNumber) {
			if (data != null) {
				switches.add(data);
			} else {
				switches.add(new SwitchData(switchNumber, Integer.MAX_VALUE));
			}
		}
		return (SwitchData) switches.get(switchNumber);
	}

}