import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToOne;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.Table;

public class Fails {
  private static final int LOOP = 20;
  private EntityManager eMgr;
  private static int excCount;

  public Fails() {
    this.eMgr = Persistence.createEntityManagerFactory("tlem").createEntityManager();
  }

  public static void main(String args[]) {
    Fails f = new Fails();
    f.create();
    for (int ix = 0; ix < LOOP; ix++) {
      f.execute();
    }
    System.out.println("Total:" + LOOP + ";Failed:" + excCount);
  }

  private void create() {
    this.eMgr.getTransaction().begin();
    BaseNode r1 = this.createResource(null, "/d/");
    this.eMgr.getTransaction().commit();
  }

  private void execute() {
    try {
      
      this.eMgr.getTransaction().begin();
      Query q2 = this.eMgr.createNamedQuery("findRepositoryObjByPath");
      q2.setParameter("path", "/d/");
      BaseNode r2 = (BaseNode) q2.getSingleResult();
      BaseNode r3 = this.createResource(((Node) r2),"/d/d/");
      BaseNode r5 = this.createResource((Node) r3, "/d/d/f");
      BaseNode r6 = this.createResource((Node) r3,"/d/d/d/");
      Query q = this.eMgr.createNamedQuery("findRepositoryObjByPath");
      q.setParameter("path", "/d/dd");
      q.getResultList();
      this.eMgr.getTransaction().commit();

      this.eMgr.getTransaction().begin();
      this.removeResource("/d/d/d/");
      this.removeResource("/d/d/f");
      this.removeResource("/d/d/");
      this.eMgr.getTransaction().commit();
      System.out.println("Ok");
    } catch (Exception e) {
      System.out.println("Failed");
      excCount++;
      // System.err.println("Failed. Reason:" + e.getMessage());
      // e.printStackTrace(System.err);
    } finally {
      if (this.eMgr.getTransaction().isActive()) {
        this.eMgr.getTransaction().rollback();
      }
    }
  }

  private BaseNode createResource(Node p, String path) {
    BaseNode ro;
    if (path.endsWith("/")) {
      ro = new Node(p, path);
    } else {
      ro = new Leaf(p, path);
    }
    this.eMgr.persist(ro);
    return ro;
  }

  private void removeResource(String path) {
    Query q = this.eMgr.createNamedQuery("findRepositoryObjByPath");
    q.setParameter("path", path);
    BaseNode r = (BaseNode) q.getSingleResult();
    this.eMgr.remove(r);
  }
}

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.INTEGER, columnDefinition = "smallint")
@Table(name = "node")
@NamedQueries( { @NamedQuery(name = "findRepositoryObjByPath", query = "SELECT r FROM BaseNode r WHERE r.path = :path") })
abstract class BaseNode implements Serializable {
  @Id @GeneratedValue @Column(name = "id") private int id;
  @OneToOne(optional = true, fetch = FetchType.LAZY, cascade = {}) @JoinColumns( { @JoinColumn(name = "parent_id") }) private BaseNode parent;
  @Basic(optional = false) @Column(name = "path", length = 250, unique = true)  private String path;

  public BaseNode() { }
  public BaseNode(BaseNode parent, String path) { this.parent = parent; this.path = path; }
  public int getId() { return id; }
  public void setId(int id) {this.id = id;}
  public String getPath() { return path; }
  public void setPath(String path) { this.path = path; }
  public BaseNode getParent() { return parent; }
  public void setParent(BaseNode parent) { this.parent = parent; }
}

@Entity @DiscriminatorValue("1")
class Leaf extends BaseNode {
  private static final long serialVersionUID = 8248481647935071792L;
  public Leaf() {super(); }
  public Leaf(BaseNode parent, String path) { super(parent, path); }
  @Override public String toString() {return "Node:(id:" + getId() + ";path:" + this.getPath() + ";parent:" + (this.getParent()!=null ? this.getParent().getId() : "") +  ")";}
}

@Entity @DiscriminatorValue("2")
class Node extends BaseNode {
  private static final long serialVersionUID = -5862223614289481555L;
  public Node() { super(); }
  public Node(BaseNode parent, String path) { super(parent, path); }
  @Override public String toString() {return "Node:(id:" + getId() + ";path:" + this.getPath() + ";parent:" + (this.getParent()!=null ? this.getParent().getId() : "") +  ")";}
}

@Entity @Table(name = "wrapper")
class Order implements java.io.Serializable {
  private static final long serialVersionUID = 7218939999165922324L;
  @Id @GeneratedValue @Column(name = "id")  private int id;
  @OneToOne(optional = true, cascade = {}) @JoinColumn(name = "leaf_id") private Leaf leaf;
  public Order() { }
  public int getId() { return id;  } 
  public void setId(int id) { this.id = id;  }
  public Leaf getLeaf() {  return this.leaf;  }
  public void setLeaf(Leaf leaf) {  this.leaf = leaf ;  }
  @Override public String toString() {return "Order:(id:" + id +  " ;Leaf:(" + leaf.toString() + ")";}
}