/*
    1. queryClosest in OC_Octree


    comparator in quadtree / octree


    hasItems -> isEmpty
      */

    // _TreeSettings change name since it's also about the data!

    // ------------------------------------------

    // make the inner core only interfaces
    // make the outer core the classes
    // make the mantle specific algorithms like pathfinding, convexhull etc.
    // make the crust what onos shell is now


    // ------------------------------------------

    // use a LocalHost for all files.
    // this way we can add links in the comments
    // this is great for images explaining something complex

    // ------------------------------------------

}

class TODO_move {/*
    Zou er een regel zijn dar er geen helipad mag alse bepaalde restricties voldoen?
     */

    // ------------------------------------------

    class jai {


        // ------------------------------------------
        class multiple_parameter_set {

            class Foo {

                void add(float x, float y, float z) {
                    // ...
                }
            }
            // !!! see how random returns 3 values based on 3 values
            foo.add(randomXYZ(width, height, 0));
        }
        // ------------------------------------------
        class pointer_to_method_to_pointer_optimazation {
            // all we would need in jai is 3 pointers to an x, y and a z
            Foo<V2> foo3 = new Foo<>(v -> v.y, v -> v.y);
            Foo<V3> foo3 = new Foo<>(v -> v.y, v -> v.y, v -> v.z);
        }
        // ------------------------------------------
        class allow_combination_abstract_final {
            // allow combination abstract and final,
            // it should:
            // -be implemented on the first class declaration that is not abstract
        }
        // ------------------------------------------

    }
    // ------------------------------------------
    // ------------------------------------------
    // ------------------------------------------
}

// ------------------------------------------
class TODO_ONOS_CORE {

    class dump {/*


        // todo IC_Math, rest of _Vec2 / _Vec3 methods



        distSq can accept a _Vec2 now, which is and experiment (_Vec3 extends _Vec2 which could give problems)

        functions is a poor name for 1 method interfaces, thinks like random and noise
        should be under functions?

        name functions lambdaMethods

        */


        _interface Item<T> {

            T item();
        }


        // ------------------------------------------

        interface _PropertyDistibutor {

        }

        class OC_PropertyDistibutor implements _PropertyDistibutor {

        }

        class SomeSketch {

            _PropertyDistibutor propertyDistibutor;
            _QuadTree quadTree;

            SomeSketch(_PropertyDistibutor propertyDistibutor, OC_QuadTree quadTree) {

                if (propertyDistibutor == null) {
                    // things like this should work with the workd concept,
                    // but they should never have an awereness of the world
                    propertyDistibutor = new OC_PropertyDistibutor();
                }

                //PVector v = new PVector();
                propertyDistibutor.add(getX, PVector, v-> v.x)
                        .add(getY, PVector, v -> v.y);
                .add(getZ, PVector, v-> v.z);

                quadTree = new OC_QuadTree<PVector>();

                int i = 0;
                while (i++ < 100) {
                    quadTree.add(random(width)*noise(0.05*i), random(height)*noise(0.05*i));
                }
            }

        }


        // ------------------------------------------

        // how do we handle normalized?
        interface _Noise {

            double noise(double x);
            double noise(double x, y);
            double noise(double x, y, z);

            void seed(long seed);
        }

        // how do we handle normalized?
        interface _Random {

            double random(double x);
            double random(double x, y);
            double random(double x, y, z);

            void seed(long seed);
        }


        // ------------------------------------------

// je moet een world maken voor je sketches. Dit zou een class moeten zijn die je deeld zodat we een world kunnen traversen.
// zo zouden we kunnen kijken of deze b.v. een quadtree gebruikt.

        // ------------------------------------------

        // je zou classes die je static aanroept moeten opvragen via de world.
// b.v. interface _Math, class OC_Math interface _OC_Math,
// or is this to prone for error?
        class Foo {

            _Math math;

            Foo() {
                math = (_Math) World.getInstance(_Math, this); // <- now the world can decide whatever one is required?
            }
        }

        class World {

            static getInstance(t : type, ? : requister) {
                if (type == _Math) {
                    //
                    if (requester == Foo) {
                        // return specific kind of math?
                        // (Math is probably a to specific example, we need something more abstract)
                        // like a physics engine
                    }
                }
                else if (...) {
                    // ..
                }
                else {
                    ... = findClassOrInterface(type);
                    ...
                }
            }

        }
        // ------------------------------------------

        class trees {


            //-select instead of query?

             //interface for level?


            // -------------

            int index_aabb[]; // from here we use offset

            // used for aabb:
            double x1_2[];
            double y1_2[];
            double z1_2[];

            // this way, finding width of quadtree can be done extreme fast as well?
            // now if we ignore z we don't even have to load it

            // ------------------------
        }

        // ------------------------------------------
        /*
        -add examples to project that don't use processing or any other library
        */
        // ------------------------------------------

        class design_patterns {
            /*
            Avoid recursion, that way we can make a pre and a post?
             */
            // -make a conventions file where we list how to break the conventions!

        }


        // ------------------------------------------
        protected C newInstance() {
            try {
                //System.out.println(this.getClass().getSimpleName());
                C c = (C) this.getClass().newInstance();
                return c;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
        // ------------------------------------------
        // we need examples in the core as well that don't draw anything
        // processing should just be able to draw and influence hwat where doing (some kind of compound)
        // we should be able to get out of what we need to create a UI
        // but this without the GUI implementation drawing
        // ------------------------------------------
         /*


          */
        // ------------------------------------------
        // is a final static getX<T> bound to the specific type?
        // as in can we do:
        // we should type in sdeudo if it can run but doesn't help for jai?

        // ------------------------------------------
        // is this possible (if not add it to some document of what java should be able to do)
        abstract class Foo<T> {

            abstract final static double x1() {}

        }
        // ------------------------------------------
         /*


          */
        // ------------------------------------------

        // ------------------------------------------

        // ------------------------------------------
         /*


          */
        // ------------------------------------------

        // ------------------------------------------

    }


}

class TODO_ONOS_SHELL {

    // maybe the 2nd shell should only provide static methods and interfaces (or first)

    // shell might be a bad name, since in a later state we could have multiple shells


}

class TODO_processing {
    // ------------------------------------------

    class OC_Tree3DTest<T> extends Problessing implements _AABB_3D {


        public static void main(String[] args) {
            Problessing.main(args);
        }


        public void settings() {
            size();
        }

        public void setup() {

        }

        public void draw() {
            draw(g);
        }

        public void draw(PGraphics pg) {


        }
    }
    // ------------------------------------------
    // je zou een PApplet als texture / 3d input etc. moeten kunnen gebruiken. Dan word het zo krachtig!!!!!!!!!!!!!!!!!!!!!
    // je moet het stand alone kunnen runnen
    // je moet doordat draw een pgraphics accepteert verschillende renderes kunnen gebruiken
    // ------------------------------------------
    // ------------------------------------------
    // ------------------------------------------

}