/**
 * proposal for an temporary solution for the minimum path loss
 * as discussed in STG 33  6 - 8 February 2013
 */
import org.seamcat.model.propagation.*;
import org.seamcat.model.technical.exception.ModelException;
import org.seamcat.propagation.HataSE21Model;
import org.seamcat.propagation.HataSE24Model;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @author Karl Koch
 * @version <strong>Temporary adaptation of the functionality <i>Minimum Coupling Loss</i> of the ILT - VLR
 *          path</strong></br> </br>
 *          <p>
 *          The plugin is restricted to:
 * 
 *          <ul>
 *          <li>Built-in propagation model Extended Hata (SE21)</li>
 *          <li>Built-in propagation model Extended Hata SRD (SE24)</li>
 *          <li>Only indoor-indoor is selectable.<br/>
 *          This takes account of the scenarios mainly considered by SE24.<br/></li>
 *          In case indoor-indoor is selected it simulates below roof top.<br/>
 *          In case indoor-indoor is not selected it simulates outdoor - outdoor.
 *          </ul>
 *          </p>
 *          <p>
 *          The plugin works as follows:
 *          <ul>
 *          <li>It is configured similar to the build-in models, except that the parameters<br/>
 *          <ul>
 *          <li>Wall loss indoor - outdoor and its standard deviation,</li>
 *          <li>Loss Between Adjacent Floor and</li>
 *          <li>Empirical Parameters</li>
 *          </ul>
 *          are not available.</li> *          
 *          <li>It calculates the path loss using the corresponding build-in model and returns then the max value of <br/>
 *          calculated path loss and the value of MCL .</li>
 *          </ul>
 *          </p>
 * 
 * 
 * 
 */
public class SE24_MinPathLoss_R2 implements PropagationPluginModel {

	private final int		INDOOR		= 0;
	private final int		OUTDOOR		= 1;
	private final int		BELOWROOF	= 1;
	private final int		ABOVEROOF	= 1;
	private final int		URBAN		= 0, SUBURBAN = 1, RURAL = 2;
	private HataSE21Model	hata;
	private HataSE24Model	hataSRD;
	private double			pathLoss;
	private int				genEnv;
	private boolean			useIndoor;
	private String			modelToUse;
	private boolean			belowRoof;
	private Double			maxAntennaGain;
	private Double			MCL;
	private Double			wallLoss;
	private Double			wallLossSTDDEV;
	private Double			sizeOfRoom;
	private Double			heightOfFloor;

	@Override
	public double evaluate(double frequency, double distance, double TxHeight, double RxHeight, boolean variation,
			Parameter... params) {

		initPlugin(params);
		if (modelToUse.endsWith("SRD")) {
			hataSRD = new HataSE24Model();
			initHataSRD(variation);
			try {
				pathLoss = hataSRD.evaluate(frequency, distance, TxHeight, RxHeight);
			} catch (ModelException e) {
				e.printStackTrace();
			}
		}
		else {
			hata = new HataSE21Model();
			initiHata(variation);

			try {
				pathLoss = hata.evaluate(frequency, distance, TxHeight, RxHeight);
			} catch (ModelException e) {
				e.printStackTrace();
			}
		}
		pathLoss = Math.max(pathLoss, MCL );
		return pathLoss;
	}

	private void initiHata(boolean variation) {
		hata.setGeneralEnv(genEnv);
		hata.setVariationsSelected(variation);
		if (belowRoof) {
			hata.setPropagEnv(BELOWROOF);
		}
		else hata.setPropagEnv(ABOVEROOF);

		if (useIndoor) {
			hata.setRxLocalEnv(INDOOR);
			hata.setTxLocalEnv(INDOOR);
		}
		else {
			hata.setRxLocalEnv(OUTDOOR);
			hata.setTxLocalEnv(OUTDOOR);
		}	
	}

	private void initHataSRD(Boolean variation) {
		hataSRD.setGeneralEnv(genEnv);
		hataSRD.setVariationsSelected(variation);
		if (belowRoof) {
			hataSRD.setPropagEnv(BELOWROOF);
		}
		else hataSRD.setPropagEnv(ABOVEROOF);

		if (useIndoor) {
			hataSRD.setRxLocalEnv(INDOOR);
			hataSRD.setTxLocalEnv(INDOOR);
		}
		else {
			hataSRD.setRxLocalEnv(OUTDOOR);
			hataSRD.setTxLocalEnv(OUTDOOR);
		}		
	}

	private void initPlugin(Parameter[] params) {
		String rGenEnv = params[0].getValue();
		if (rGenEnv.equals("Rural")) genEnv = RURAL;
		else if (rGenEnv.equals("Suburban")) genEnv = SUBURBAN;
		else genEnv = URBAN;

		String rModel = params[1].getValue();
		if (rModel.endsWith("SRD")) modelToUse = "HATA SRD";
		else modelToUse = "HATA";

		useIndoor = params[2].isEnabled();
		belowRoof = params[3].isEnabled();
		if(useIndoor)belowRoof = true;
		MCL = params[4].getValue();
	}

	@Override
	public List<ParameterDefinition> getParameterDefinitions() {
		List<ParameterDefinition> parameters = new ArrayList<ParameterDefinition>();
		parameters.add(new SelectionParameter("General Environment", "Rural", "Suburban", "Urban"));
		parameters.add(new SelectionParameter("Model to be used", "Extended Hata", "Extended Hata SRD"));
		parameters.add(new BooleanParameter("simulate indoor-indoor").defaultValue(true).description("if not selected it simulates outdoor - outdoor"));		
		parameters.add(new BooleanParameter("simulate below roof top").defaultValue(false));		
		parameters.add(new DoubleParameter("Minimum Coupling Loss").defaultValue(0.0).unit("dB"));
		return parameters;
	}

}