package hyperspace;

import java.util.concurrent.ConcurrentLinkedDeque;

/*
 * Oh! This is only a first appraoach-sketch
 * for too much massive complex mass!
 * Wait patiently, because this is only by the event!
 * I'm programming this for all of you!
 * You will be very, very, happy. Your best wishes!
 * I have to say that you haven't told me how you want your
 * idilic place! I think this will be enough good for you!
 * How many virgins you want? 600, 60, 6? Tell me, tell me.
 * I'm all listeners!
 * Sure, you will be like the Lord walking across his garden!
 * temps.Anem
 */
public interface Hell {

   /*
    * This is only a sketch. A previous and parent version.
    * In a few java.util.EventObject before will recur some more!
    * For who will be this beauty and concurrent java.lang.Class<?>
    * This is from the parent implementation of hyperspace.Hell!
    */
    public final class Nightmare
        implements java.util.concurrent.Future<Nightmare>,
            java.util.concurrent.Executor,
            java.lang.Runnable {

        private Nightmare sinner;

        public Nigthmare get() {
            return sinner;
        }
        public void set(Nightmare sinner) {
            this.sinner = sinner;
        }

        public Nightmare() {
            this.sinner = this;
        }
        public Nightmare(Nightmare sinner) {
            this.sinner = sinner.get();
            sinner.set(this);
        }
        // The bulk java.lang.reflect.Constructor!
        public Nightmare(ConcurrentLinkedDeque<Nightmare> hell) {
            while(!hell.isEmpty()) {
                new Nightmare (hell.poll())
            }
        }

        public void run() {
            // Call public final static-default punishment
            Hell.Punishment.sodom(this);
            // Make feel this pain to future nightmare sinner
            sendMass(new java.util.EventObject(this);
            // execute nightmare for next sinner child
            // concurrently to the future
            execute(get());
        }

        public feelPain(Object source, java.util.EventObject pain) {
            // Concur pain to child instance
            this.sendMass(pain)
            // Cast event source
            Nightmare sin = (Nightmare) pain.getSource();
            // Burn!
            execute(sin);
        }

        protected void sendMass(java.util.EventObject pain) {
            get().feelPain(pain);
        }
    }
    // If you have some proposals to improve
    // your favourite place you do it!
    // Then I will try to satisfy your best wishes!
    // But I if you don't say me
    // nothing I will think that is O.K.! Is it O.K.?
    // If it is, you only have to don't tell me nothing!
}