/*******************************************************************************
 * Copyright (c) 2004, 2007 Boeing.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Boeing - initial API and implementation
 *******************************************************************************/
package org.eclipse.osee.ote.message.elements;

import java.util.logging.Level;
import org.eclipse.osee.framework.logging.OseeLog;
import org.eclipse.osee.ote.core.MethodFormatter;
import org.eclipse.osee.ote.core.environment.interfaces.ITestEnvironmentAccessor;
import org.eclipse.osee.ote.core.testPoint.CheckGroup;
import org.eclipse.osee.ote.message.Message;
import org.eclipse.osee.ote.message.MessageSystemTestEnvironment;
import org.eclipse.osee.ote.message.data.MemoryResource;
import org.eclipse.osee.ote.message.data.MessageData;
import org.eclipse.osee.ote.message.elements.nonmapping.NonMappingFixedPointElement;
import org.eclipse.osee.ote.message.interfaces.ITestAccessor;

/**
 * @author Andrew M. Finkbeiner
 * @author John Butler
 */
public class FixedPointElement extends RealElement {

   private final double resolution;
   private final boolean signed;
   private final double offset;

   public FixedPointElement(Message message, String elementName, MessageData messageData, double resolution, boolean signed, int byteOffset, int msb, int lsb) {
      this(message, elementName, messageData, resolution, 0, signed, byteOffset, msb, lsb, msb, lsb);
   }

   public FixedPointElement(Message message, String elementName, MessageData messageData, double resolution, double offset, boolean signed, int byteOffset, int msb, int lsb) {
      this(message, elementName, messageData, resolution, offset, signed, byteOffset, msb, lsb, msb, lsb);
   }

   public FixedPointElement(Message message, String elementName, MessageData messageData, double resolution, boolean signed, int byteOffset, int msb, int lsb, int originalLsb, int originalMsb) {
      this(message, elementName, messageData, resolution, 0, signed, byteOffset, msb, lsb, originalLsb, originalMsb);
   }

   public FixedPointElement(Message message, String elementName, MessageData messageData, double resolution, double offset, boolean signed, int byteOffset, int msb, int lsb, int originalLsb, int originalMsb) {
      super(message, elementName, messageData, byteOffset, msb, lsb, originalLsb, originalMsb);
      this.resolution = resolution;
      this.signed = signed;
      this.offset = offset;
   }

   public FixedPointElement(Message message, String elementName, MessageData messageData, double resolution, double offset, boolean signed, int bitOffset, int bitLength) {
      super(message, elementName, messageData, bitOffset, bitLength);
      this.resolution = resolution;
      this.signed = signed;
      this.offset = offset;
   }

   /**
    * Sets the element to the "value" passed.
    * 
    * @param value The value to set.
    */
   @Override
   public void set(ITestEnvironmentAccessor accessor, double value) {
      if (accessor != null) {
         accessor.getLogger().methodCalledOnObject(accessor, this.getFullName(), new MethodFormatter().add(value),
            this.getMessage());
      }
      setValue(value);

      if (accessor != null) {
         accessor.getLogger().methodEnded(accessor);
      }
   }

   /**
    * Sets the element to the "value" passeda nd immediately sends the message that contains it...
    * 
    * @param value The value to set.
    */
   @Override
   public void setAndSend(ITestEnvironmentAccessor accessor, double value) {
      this.set(accessor, value);
      super.sendMessage();
   }

   public void setNoLog(ITestEnvironmentAccessor accessor, double value) {
      setValue(value);
   }

   /**
    * Checks that this element correctly forwards a message sent from cause with the value passed.
    * 
    * @param cause The originator of the signal
    * @param value The value sent by cause and being forwarded by this element
    */
   public void checkForwarding(ITestAccessor accessor, FixedPointElement cause, double value) throws InterruptedException {
      /* check for 0 to begine */
      check(accessor, 0d, 0);

      /* Set the DP1 Mux Signal */
      cause.set(accessor, value);

      /* Chk Value on DP2 */
      check(accessor, value, 1000);

      /* Set DP1 to 0 */
      cause.set(accessor, 0);

      /* Init DP2 Mux to 0 */
      set(accessor, 0);

      /* Chk Value on DP2 is still set */
      check(accessor, value, 500);

      /* Chk DP2 is 0 for two-pulse signals and high for four-oulse signal */
      check(accessor, 0d, 500);
   }

   private double toFixed(long value, boolean signed, double resolution, double offset) {
      int shift = 64 - (lsb - msb + 1);
      if (signed) {// two's compliment
         if (value >>> lsb - msb == 1) {// we've got a negative
            value--;
            value = ~value;
            value = value << shift;
            value = value >>> shift;
            value = value * -1;
         }
      } else {
         value = value << shift;
         value = value >>> shift;
      }
      return value * resolution + offset;
   }

   private long toFixedLong(double value, boolean signed, double resolution, double offset) {
      long returnValue = Math.round((value - offset) / resolution);

      if (value > 0 && toFixed(returnValue, signed, resolution, offset) < 0) {
         returnValue = Math.round((value - resolution - offset) / resolution);
         if (value > 0 && toFixed(returnValue, signed, resolution, offset) < 0) {
            returnValue = Math.round((value - resolution * 2 - offset) / resolution);
            if (value > 0 && toFixed(returnValue, signed, resolution, offset) < 0) {
               OseeLog.log(MessageSystemTestEnvironment.class, Level.INFO, getName());
            } else {
               OseeLog.log(MessageSystemTestEnvironment.class, Level.INFO, getName());
            }
         } else {
            OseeLog.log(MessageSystemTestEnvironment.class, Level.INFO, getName());
         }
      }

      if (signed && value < 0) {
         returnValue = returnValue * -1;
         int shift = 64 - (lsb - msb + 1);
         returnValue = returnValue << shift;
         returnValue = ~returnValue;
         returnValue = returnValue >>> shift;
         returnValue++;
      }
      return returnValue;
   }

   @Override
   public void setValue(Double obj) {
      getMsgData().getMem().setLong(toFixedLong(obj, signed, resolution, offset), byteOffset, msb, lsb);
   }

   @Override
   public void setHex(long hex) {
      getMsgData().getMem().setLong(hex, byteOffset, msb, lsb);
   }

   @Override
   public Double getValue() {
      return toFixed(getRaw(), signed, resolution, offset);
   }

   @Override
   public Double valueOf(MemoryResource mem) {
      return toFixed(getRaw(mem), signed, resolution, offset);
   }

   @Override
   protected double toDouble(long value) {
      return toFixed(value, signed, resolution, offset);
   }

   @Override
   protected long toLong(double value) {
      return toFixedLong(value, signed, resolution, offset);
   }

   /**
    * @return Returns the offset.
    */
   public double getMinVal() {
      return offset;
   }

   /**
    * @return Returns the resolution.
    */
   public double getResolution() {
      return resolution;
   }

   /**
    * @return Returns the signed.
    */
   public boolean isSigned() {
      return signed;
   }

   @Override
   public void visit(IElementVisitor visitor) {
      visitor.asFixedPointElement(this);
   }

   @Override
   protected NonMappingFixedPointElement getNonMappingElement() {
      return new NonMappingFixedPointElement(this);
   }

   @Override
   public boolean check(ITestAccessor accessor, CheckGroup checkGroup, Double value, int milliseconds) throws InterruptedException {
      return super.check(accessor, checkGroup, adjust(value), milliseconds);
   }

   @Override
   public boolean check(ITestAccessor accessor, CheckGroup checkGroup, Double value) {
      return super.check(accessor, checkGroup, adjust(value));
   }

   @Override
   public boolean checkList(ITestAccessor accessor, CheckGroup checkGroup, boolean isInList, Double[] list, int milliseconds) throws InterruptedException {
      return super.checkList(accessor, checkGroup, isInList, adjust(list), milliseconds);
   }

   @Override
   public boolean checkList(ITestAccessor accessor, CheckGroup checkGroup, boolean wantInList, Double[] list) {
      return super.checkList(accessor, checkGroup, wantInList, adjust(list));
   }

   @Override
   public Double checkMaintain(ITestAccessor accessor, CheckGroup checkGroup, Double value, int milliseconds) throws InterruptedException {
      return super.checkMaintain(accessor, checkGroup, adjust(value), milliseconds);
   }

   @Override
   public Double checkMaintainList(ITestAccessor accessor, CheckGroup checkGroup, Double[] list, boolean isInList, int milliseconds) throws InterruptedException {
      return super.checkMaintainList(accessor, checkGroup, adjust(list), isInList, milliseconds);
   }

   @Override
   public Double checkMaintainNot(ITestAccessor accessor, CheckGroup checkGroup, Double value, int milliseconds) throws InterruptedException {
      return super.checkMaintainNot(accessor, checkGroup, adjust(value), milliseconds);
   }

   @Override
   public Double checkMaintainNotRange(ITestAccessor accessor, CheckGroup checkGroup, Double minValue, boolean minInclusive, Double maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
      return super.checkMaintainNotRange(accessor, checkGroup, minValue, minInclusive, maxValue, maxInclusive,
         milliseconds);
   }

   @Override
   public Double checkMaintainRange(ITestAccessor accessor, CheckGroup checkGroup, Double minValue, boolean minInclusive, Double maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
      return super.checkMaintainRange(accessor, checkGroup, minValue, minInclusive, maxValue, maxInclusive,
         milliseconds);
   }

   @Override
   public boolean checkNot(ITestAccessor accessor, CheckGroup checkGroup, Double value, int milliseconds) throws InterruptedException {
      return super.checkNot(accessor, checkGroup, adjust(value), milliseconds);
   }

   @Override
   public boolean checkNot(ITestAccessor accessor, CheckGroup checkGroup, Double value) {
      return super.checkNot(accessor, checkGroup, adjust(value));
   }

   @Override
   public boolean checkNotRange(ITestAccessor accessor, CheckGroup checkGroup, Double minValue, boolean minInclusive, Double maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
      return super.checkNotRange(accessor, checkGroup, minValue, minInclusive, maxValue, maxInclusive, milliseconds);
   }

   @Override
   public boolean checkPulse(ITestAccessor accessor, CheckGroup checkGroup, Double pulsedValue, Double nonPulsedValue, int milliseconds) throws InterruptedException {
      return super.checkPulse(accessor, checkGroup, adjust(pulsedValue), adjust(nonPulsedValue), milliseconds);
   }

   @Override
   public boolean checkRange(ITestAccessor accessor, CheckGroup checkGroup, Double minValue, boolean minInclusive, Double maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
      return super.checkRange(accessor, checkGroup, minValue, minInclusive, maxValue, maxInclusive, milliseconds);
   }

   @Override
   public boolean checkRange(ITestAccessor accessor, CheckGroup checkGroup, Double minValue, boolean minInclusive, Double maxValue, boolean maxInclusive) {
      return super.checkRange(accessor, checkGroup, minValue, minInclusive, maxValue, maxInclusive);
   }

   @Override
   public Double waitForList(ITestAccessor accessor, Double[] list, boolean isInList, int milliseconds) throws InterruptedException {
      return super.waitForList(accessor, adjust(list), isInList, milliseconds);
   }

   @Override
   public Double waitForNotRange(ITestEnvironmentAccessor accessor, Double minValue, boolean minInclusive, Double maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
      return super.waitForNotRange(accessor, minValue, minInclusive, maxValue, maxInclusive, milliseconds);
   }

   @Override
   public Double waitForNotValue(ITestEnvironmentAccessor accessor, Double value, int milliseconds) throws InterruptedException {
      return super.waitForNotValue(accessor, adjust(value), milliseconds);
   }

   @Override
   public Double waitForRange(ITestEnvironmentAccessor accessor, Double minValue, boolean minInclusive, Double maxValue, boolean maxInclusive, int milliseconds) throws InterruptedException {
      return super.waitForRange(accessor, minValue, minInclusive, maxValue, maxInclusive, milliseconds);
   }

   @Override
   public Double waitForValue(ITestEnvironmentAccessor accessor, Double value, int milliseconds) throws InterruptedException {
      return super.waitForValue(accessor, adjust(value), milliseconds);
   }

   private Double adjust(Double value) {
      return toDouble(toLong(value));
   }

   private Double[] adjust(Double[] list) {
      Double[] newList = new Double[list.length];
      for (int i = 0; i < list.length; i++) {
         newList[i] = adjust(list[i]);
      }
      return newList;
   }
}