package ordertracker;
   
   import com.google.common.base.MoreObjects;
   import com.google.common.base.Optional;
   import com.google.common.collect.Sets;
   import java.io.Serializable;
   import java.lang.Class;
   import java.lang.Double;
   import java.lang.IllegalAccessException;
  import java.lang.IllegalArgumentException;
  import java.lang.InstantiationException;
  import java.lang.NullPointerException;
  import java.lang.Override;
  import java.lang.SecurityException;
  import java.lang.String;
  import java.lang.SuppressWarnings;
  import java.lang.System;
  import java.lang.reflect.InvocationTargetException;
  import java.math.BigDecimal;
  import java.util.Set;
  import java.util.concurrent.TimeUnit;
  import java.util.regex.Pattern;
  import javax.persistence.CascadeType;
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.EntityManager;
  import javax.persistence.FetchType;
  import javax.persistence.Id;
  import javax.persistence.OneToMany;
  import javax.persistence.PrePersist;
  import javax.persistence.PreUpdate;
  import javax.persistence.Table;
  import javax.persistence.Transient;
  import ordertracker.Order;
  import scala.concurrent.duration.Duration;
  import xuml.tools.model.compiler.runtime.BehaviourFactoryNotSetException;
  import xuml.tools.model.compiler.runtime.CreationEvent;
  import xuml.tools.model.compiler.runtime.EntityHelper;
  import xuml.tools.model.compiler.runtime.Event;
  import xuml.tools.model.compiler.runtime.Signaller;
  import xuml.tools.model.compiler.runtime.ValidationException;
  import xuml.tools.model.compiler.runtime.query.BooleanExpression;
  import xuml.tools.model.compiler.runtime.query.NumericExpressionField;
  import xuml.tools.model.compiler.runtime.query.SelectBuilder;
  import xuml.tools.model.compiler.runtime.query.StringExpressionField;
  
  /**
   * 
   */
  @Entity
  @Table(schema="ordertracker", name="depot")
  public class Depot implements xuml.tools.model.compiler.runtime.Entity<Depot> {
  
      /**
       * No argument constructor required by JPA.
       */
      public Depot(){
          //JPA requires no-arg constructor
          if (_behaviourFactory == null) {
              throw new BehaviourFactoryNotSetException("Depot does not have a BehaviourFactory set. Use Depot.setBehaviourFactory in your App class (one-time setup).");
          }
          _behaviour = _behaviourFactory.create(this);
      }
  
      /**
       * If behaviour is not explicitly specified then the
       * behaviour factory is used to create behaviour.
       */
      private static volatile BehaviourFactory _behaviourFactory;
  
      /**
       * All actions like onEntry actions and defined
       * operations are performed by this Behaviour class.
       */
      @Transient
      private Behaviour _behaviour;
  
      /**
       * Sets the BehaviourFactory for all instances of
       * this class. It will only be used when Behaviour
       * is not explicitly provided in the constructor.
       */
      public static void setBehaviourFactory(BehaviourFactory factory){
          _behaviourFactory = factory;
      }
  
      /**
       * Sets the BehaviourFactory for all instances of
       * this class using the given Behaviour class as the base. It will only be used when Behaviour
       * is not explicitly provided in the constructor.
       */
      public static void setBehaviourFactory(Class<? extends Behaviour> cls){
          _behaviourFactory = createBehaviourFactory(cls);
      }
  
      /**
       * Returns the singleton BehaviourFactory for this.
       */
      public static BehaviourFactory getBehaviourFactory(){
         return _behaviourFactory;
     }
 
     /**
      * Constructor using id.
      */
     public Depot(String id) {
         this.id = id;
     }
 
     /**
      * Static creator method using id.
      */
     public static Depot create(String id) {
         return new Depot(id);
     }
 
     /**
      * Static creator method using CreationEvent.
      */
     public static Depot create(CreationEvent<Depot> creationEvent) {
         return Context.create(Depot.class, creationEvent);
     }
 
     /**
      * The signaller used by the current Context. It will
      * get injected into the EntityHelper.
      */
     private static Signaller signaller;
 
     /**
      * Sets the Signaller to be used by the EntityHelper.
      */
     static void setSignaller_(Signaller sig) {
         signaller = sig;
     }
 
     /**
      * Helper for this class.
      */
     @Transient
     private EntityHelper _helper;
 
     /**
      * Returns the Helper for this instance.
      */
     public synchronized EntityHelper helper() {
         if (_helper==null)
             _helper = new EntityHelper(signaller,this);
         return _helper;
     }
 
     /**
      * Primary identifier
      */
     @Id
     @Column(name="depot_id", nullable=false,length=2048)
     private String id = new String("");
 
     /**
      * Returns a unique id for this instance as a String. 
      * Used for synchronizing access to entities.
      */
     @Override
     public String uniqueId(){
         return Depot.class.getName() + ":" + getId();
     }
 
     @Column(name="name_1", nullable=false,length=255)
     private String name = new String("");
 
     /**
      * Validates name against type constraints.
      */
     private void validateName() {
         if (name == null || name.length() < 1)
             throw new ValidationException("min length constraint not met");
          if (name == null || !name.startsWith(""))
             throw new ValidationException("prefix constraint not met");
         if (name == null || !name.endsWith(""))
             throw new ValidationException("suffix constraint not met");
         if (name == null || !Pattern.matches(".*", name))
             throw new ValidationException("validation pattern constraint not met");
     }
 
     @Column(name="latitude", nullable=false,precision=20)
     private Double latitude = new Double("0");
 
     private static final BigDecimal LATITUDE_UPPER_LIMIT=new BigDecimal("90");
     private static final BigDecimal LATITUDE_LOWER_LIMIT=new BigDecimal("-90");
 
     /**
      * Validates latitude against type constraints.
      */
     private void validateLatitude() {
         if (LATITUDE_UPPER_LIMIT.doubleValue() < latitude) 
             throw new ValidationException("upper limit of 90 failed");
         if (LATITUDE_LOWER_LIMIT.doubleValue() > latitude)
              throw new ValidationException("lower limit of -90 failed");
     }
 
     @Column(name="longitude", nullable=false,precision=20)
     private Double longitude = new Double("0");
 
     private static final BigDecimal LONGITUDE_UPPER_LIMIT=new BigDecimal("180");
     private static final BigDecimal LONGITUDE_LOWER_LIMIT=new BigDecimal("-180");
 
     /**
      * Validates longitude against type constraints.
      */
     private void validateLongitude() {
         if (LONGITUDE_UPPER_LIMIT.doubleValue() < longitude) 
             throw new ValidationException("upper limit of 180 failed");
         if (LONGITUDE_LOWER_LIMIT.doubleValue() > longitude)
              throw new ValidationException("lower limit of -180 failed");
     }
 
     /**
      * For internal use only by the state machine but is persisted by the jpa provider.
      */
     @Column(name="state",nullable=false)
     private String state;
 
     /**
      * ZERO_ONE Depot is last location of MANY Order
      */
     @OneToMany(mappedBy="depot_R1", cascade=CascadeType.ALL, fetch=FetchType.LAZY, targetEntity=Order.class)
     private Set<Order> order_R1 = Sets.newHashSet();
 
     /**
      * Getter. ZERO_ONE Depot is last location of MANY Order
      */
     public Set<Order> getOrder_R1(){
         return order_R1;
     }
 
     /**
      * Setter. ZERO_ONE Depot is last location of MANY Order
      */
     public void setOrder_R1(Set<Order> order_R1){
         this.order_R1=order_R1;
     }
 
     /**
      * ZERO_ONE Depot is last location of MANY Order
      */
     public Depot relateAcrossR1(Order order_R1) {
         order_R1.setDepot_R1(this);
         return this;
     }
 
     /**
      * ZERO_ONE Depot is last location of MANY Order
      */
     public Depot unrelateAcrossR1(Order order_R1) {
         getOrder_R1().remove(order_R1);
         order_R1.setDepot_R1(null);
         return this;
     }
 
     /**
      * Calls all validation methods just before updating database.
      */
     @PreUpdate
     void validateBeforeUpdate(){
         validateLatitude();
         validateLongitude();
         validateName();
     }
 
     /**
      * Calls all validation methods just before first persist of this entity.
      */
     @PrePersist
     void validateBeforePersist(){
         validateLatitude();
         validateLongitude();
         validateName();
     }
 
     /**
      * Returns the identifier for this entity.
      */
     public String getId() {
         return id;
     }
 
     public void setId(String id) {
         this.id = id;
     }
 
     public Depot setId_(String id) {
         this.id = id;
         return this;
     }
 
     /**
      * Returns name. 
      */
     public String getName(){
         return name;
     }
 
     /**
      * Sets name to the given value. 
      */
     public void setName(String name){
         this.name = name;
     }
 
     /**
      * Sets the attribute to the given value and returns this
      * (enables method chaining).
      */
     public Depot setName_(String name){
         setName(name);
         return this;
     }
 
     /**
      * Returns latitude. 
      */
     public Double getLatitude(){
         return latitude;
     }
 
     /**
      * Sets latitude to the given value. 
      */
     public void setLatitude(Double latitude){
         this.latitude = latitude;
     }
 
     /**
      * Sets the attribute to the given value and returns this
      * (enables method chaining).
      */
     public Depot setLatitude_(Double latitude){
         setLatitude(latitude);
         return this;
     }
 
     /**
      * Returns longitude. 
      */
     public Double getLongitude(){
         return longitude;
     }
 
     /**
      * Sets longitude to the given value. 
      */
     public void setLongitude(Double longitude){
         this.longitude = longitude;
     }
 
     /**
      * Sets the attribute to the given value and returns this
      * (enables method chaining).
      */
     public Depot setLongitude_(Double longitude){
         setLongitude(longitude);
         return this;
     }
 
     /**
      * For internal use only by the state machine but is persisted by the jpa provider.
      */
     public String getState(){
         return state;
     }
 
     /**
      * For internal use only by the state machine but is persisted by the jpa provider.
      */
     public void setState(String state){
         this.state = state;
     }
 
     /**
      * Sets the current state. This should only be used when creating an instance without using the state machine.
      */
     public void setState(State state){
         this.state = state.toString();
     }
 
     /**
      * The list of all states from the state machine for this entity.
      */
     public static enum State {
         CREATED;
     }
 
     /**
      * Event declarations.
      */
     public static class Events {
 
         /**
          * Event implementation for event 'Create'
          */
         @SuppressWarnings("serial")
         public static class Create implements Event<Depot>, Serializable, CreationEvent<Depot> {
 
             public static final String signatureKey = "java.lang.String;java.lang.String;java.lang.Double;java.lang.Double;";
 
             public String signatureKey() {
                 return signatureKey;
             }
             private final String depotID;
             private final String name;
             private final Double latitudet;
             private final Double longitude;
 
             /**
              * Constructor.
              */
             public Create(String depotID, String name, Double latitudet, Double longitude){
                 if (depotID == null) throw new NullPointerException("depotID cannot be null");
                 this.depotID = depotID;
                 if (name == null) throw new NullPointerException("name cannot be null");
                 this.name = name;
                 if (latitudet == null) throw new NullPointerException("latitudet cannot be null");
                 this.latitudet = latitudet;
                 if (longitude == null) throw new NullPointerException("longitude cannot be null");
                 this.longitude = longitude;
             }
 
             public String getDepotID(){
                 return depotID;
             }
 
             public String getName(){
                 return name;
             }
 
             public Double getLatitudet(){
                 return latitudet;
             }
 
             public Double getLongitude(){
                 return longitude;
             }
 
             private Create(Builder builder) {
                 if (builder.depotID == null) throw new NullPointerException("depotID cannot be null");
                 this.depotID = builder.depotID;
                 if (builder.name == null) throw new NullPointerException("name cannot be null");
                 this.name = builder.name;
                 if (builder.latitudet == null) throw new NullPointerException("latitudet cannot be null");
                 this.latitudet = builder.latitudet;
                 if (builder.longitude == null) throw new NullPointerException("longitude cannot be null");
                 this.longitude = builder.longitude;
             }
 
             public static Builder builder() {
                 return new Builder();
             }
 
             public static class Builder {
 
                 private String depotID;
                 private String name;
                 private Double latitudet;
                 private Double longitude;
 
                 public Builder depotID(String depotID) {
                     this.depotID = depotID;
                     return this;
                 }
 
                 public Builder name(String name) {
                     this.name = name;
                     return this;
                 }
 
                 public Builder latitudet(Double latitudet) {
                     this.latitudet = latitudet;
                     return this;
                 }
 
                 public Builder longitude(Double longitude) {
                     this.longitude = longitude;
                     return this;
                 }
 
                 public Create build() {
                     return new Create(this);
                 }
             }
 
             @Override
             public String toString() {
                 return MoreObjects.toStringHelper(this.getClass())
                     .add("depotID", depotID)
                     .add("name", name)
                     .add("latitudet", latitudet)
                     .add("longitude", longitude)
                     .toString();
             }
         }
 
     }
 
     /**
      * Asychronously queues the given signal against this entity for processing.
      */
     @Override
     public Depot signal(Event<Depot> event) {
         helper().signal(event);
         return this;
     }
 
     /**
      * Asychronously queues the given signal against this entity for processing
      * after the delay specified. Delay cannot be null.
      */
     @Override
     public Depot signal(Event<Depot> event, Duration delay) {
         helper().signal(event, Optional.of(delay));
         return this;
     }
 
     /**
      * Asychronously queues the given signal against this entity for processing
      * at the epoch time in ms specified. Delay cannot be null.
      */
     @Override
     public Depot signal(Event<Depot> event, long time) {
         return signal(event, Duration.create(time-System.currentTimeMillis(),TimeUnit.MILLISECONDS));
     }
 
     public Depot cancelSignal(String eventSignatureKey) {
          return this;
     }
 
     public Depot cancelSignal(Event<Depot> event) {
          return cancelSignal(event.signatureKey());
     }
 
     /**
      * Synchronously runs the on entry procedure associated
      * with this event and also any signals to self that are
      * made during the procedure. This method should not
      * be called directly except in a unit testing scenario
      * perhaps. Call signal method instead.
      */
     @Override
     public Depot event(Event<Depot> event){
 
         helper().beforeEvent();
 
         // process the event
         if (event instanceof Events.Create){
             processEvent((Events.Create) event);
         }
 
         helper().afterEvent();
         return this;
     }
 
     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.Create event){
         if (state==null){
             state=State.CREATED.toString();
             synchronized(this) {
                 _behaviour.onEntryCreated(event);
             }
         }
     }
 
     /**
      * Static creator method associated with the creation transition to 'Created' via event 'Create'.
      */
     public static Depot create(EntityManager em, CreationEvent<Depot> event) {
         Depot entity = new Depot();
         entity.event(event);
         em.persist(entity);
         return entity;
     }
 
     /**
      * Same as EntityManager.merge() except allows method chaining.
      * Returns a new merged instance.
      */
     public Depot merge(EntityManager em) {
         return em.merge(this);
     }
 
     /**
      * Same as EntityManager.persist() except allows method chaining. Returns this.
      */
     public Depot persist(EntityManager em) {
         em.persist(this);
         return this;
     }
 
 
     /**
      * Same as {@code persist(Context.em())}. Returns this.
      */
     public Depot persist() {
         Context.em().persist(this);
         return this;
     }
 
     /**
      * Same as EntityManager.remove() except inverted to facilitate method chaining. Returns this.
      */
     public Depot remove(EntityManager em) {
         em.remove(this);
         return this;
     }
 
     /**
      * Same as EntityManager.remove() except inverted to facilitate method chaining. Returns this.
      */
     public Depot remove() {
         Context.remove(this);
         return this;
     }
 
     /**
      * Same as this.remove()
      */
     public Depot delete() {
         return remove();
     }
 
     /**
      * Same as EntityManager.refresh() except inverted to facilitate method chaining. Returns this.
      */
     public Depot refresh(EntityManager em) {
         em.refresh(this);
         return this;
     }
 
     /**
      * Does a merge then a refresh and returns a new updated merged instance.
      */
     public Depot load(EntityManager em) {
         return merge(em).refresh(em);
     }
 
     public Depot load() {
         return Context.load(this);
     }
 
     /**
      * On entry procedures for this entity.
      */
     public static interface Behaviour {
 
         void onEntryCreated(Events.Create event);
 
     }
 
     /**
      * A factory that creates behaviour for a given entity.
      */
     public static interface BehaviourFactory {
 
         Behaviour create(Depot entity);
 
     }
 
     /**
      * Returns a BehaviourFactory on the assumption that the given class
      * has a single constructor with one parameter of type Depot.
      */
     public static BehaviourFactory createBehaviourFactory(final Class<? extends Behaviour> cls) {
         return new BehaviourFactory() {
             @Override
             public Behaviour create(Depot entity) {
                 if (cls.getConstructors().length != 1)
                      throw new RuntimeException(
                               "expected only one constructor in the Behaviour implementation");
                 try {
                     return (Behaviour) cls.getConstructors()[0].newInstance(entity);
                 } catch (InstantiationException e) {
                     throw new RuntimeException(e);
                 } catch (IllegalAccessException e) {
                     throw new RuntimeException(e);
                 } catch (IllegalArgumentException e) {
                     throw new RuntimeException(e);
                 } catch (InvocationTargetException e) {
                     throw new RuntimeException(e);
                 } catch (SecurityException e) {
                     throw new RuntimeException(e);
                 }
             }
         };
     }
 
     public static Optional<Depot> find(String id) {
         if (Context.em()!=null) {
             return Optional.fromNullable(Context.em().find(Depot.class,id));
         } else {
             EntityManager em = Context.createEntityManager();
             try {
                 Depot result = em.find(Depot.class,id);
                 return Optional.fromNullable(result);
             } finally {
                 em.close();
             }
         }
     }
 
     public static class Attribute {
         public static final StringExpressionField<Depot> name = new StringExpressionField<Depot>(
             new xuml.tools.model.compiler.runtime.query.Field("name"));
         public static final NumericExpressionField<Depot> latitude = new NumericExpressionField<Depot>(
             new xuml.tools.model.compiler.runtime.query.Field("latitude"));
         public static final NumericExpressionField<Depot> longitude = new NumericExpressionField<Depot>(
             new xuml.tools.model.compiler.runtime.query.Field("longitude"));
         public static final StringExpressionField<Depot> id = new StringExpressionField<Depot>(
             new xuml.tools.model.compiler.runtime.query.Field("id"));
         public static final StringExpressionField<Depot> order_R1_id = new StringExpressionField<Depot>(
             new xuml.tools.model.compiler.runtime.query.Field("order_R1.id"));
     }
 
     public static SelectBuilder<Depot> select(BooleanExpression<Depot> where) {
         return new SelectBuilder<Depot>(where).entityClass(Depot.class).info(signaller.getInfo());
     }
 
     public static SelectBuilder<Depot> select() {
         return select(null);
     }
 
 }