#lang racket

(require (for-syntax racket/syntax))
(require "base/coord.rkt"
         "base/bounding-box.rkt"
         ;"base/main.rkt"
         (only-in "com.rkt" debug-com step-com)
         (prefix-in ac: "autocad/ac-com.rkt")
         (prefix-in rh: "rhinoceros3d/rh-com.rkt")
         ;(prefix-in gl: "opengl/opengl.rkt")
         (prefix-in gl: "opengl/opengl.rkt")
         (prefix-in tz: "tikz/tikz.rkt")
         )

;(provide (all-from-out (prefix-in ac: "autocad/ac-com.rkt")))

(provide debug-com step-com)


#|



|#


;;Utilities to be moved to some other place:

(provide division)
(define-sequence-syntax division
  (lambda () #'division/proc)
  (lambda (stx)
    (syntax-case stx ()
      [[(v) (clause from to elems)]
       #'[(v)
          (clause from to elems #t)]]
      [[(v) (_ from to elems last?)]
       #`[(v)
          (:do-in
           ([(a) from] [(b) to] [(n) elems]
            #,@(case (syntax-e #'last?)
                 ((#t #f) #'())
                 (else #'([(pred) (if last? <= <)]))))
           (unless (exact-positive-integer? n)
             (raise-type-error 'division "exact non-negative integer" n))
           ([i 0])
           (#,(case (syntax-e #'last?)
               ((#t) #'<=)
               ((#f) #'<)
               (else #'pred))
            i n)
           ([(v) (+ a (/ (* i (- b a)) n))])
           #true
           #true
           ((+ i 1)))]])))

(define (division/proc a b n [last? #t])
  (if last?
      (for/list ([t (division a b n #t)])
        t)
      (for/list ([t (division a b n #f)])
        t)))

(provide map-division)
(define map-division
  (case-lambda
    ((f t0 t1 n)
     (for/list ((t (division t0 t1 n)))
       (f t)))
    ((f t0 t1 n last?)
     (for/list ((t (division t0 t1 n last?)))
       (f t)))
    ((f u0 u1 nu v0 v1 nv)
     (for/list ((u (division u0 u1 nu)))
       (for/list ((v (division v0 v1 nv)))
         (f u v))))
    ((f u0 u1 nu lastu? v0 v1 nv)
     (for/list ((u (division u0 u1 nu lastu?)))
       (for/list ((v (division v0 v1 nv)))
         (f u v))))
    ((f u0 u1 nu lastu? v0 v1 nv lastv?)
     (for/list ((u (division u0 u1 nu lastu?)))
       (for/list ((v (division v0 v1 nv lastv?)))
         (f u v))))))

(provide in-interval)
(define-sequence-syntax in-interval
  (lambda () #'in-interval/proc)
  (lambda (stx)
    (syntax-case stx ()
      [[(v) (_ from to elems)]
       #'[(v)
          (:do-in
           ([(a) from] [(b) to] [(n) elems])
           (unless (exact-positive-integer? n)
             (raise-type-error 'in-interval "exact non-negative integer" n))
           ([i 0])
           (<= i n)
           ([(v) (+ a (/ (* i (- b a)) n))])
           #true
           #true
           ((+ i 1)))]])))

(define (in-interval/proc a b n)
  (for/list ([t (in-interval a b n)])
    t))

(provide in-period)
(define-sequence-syntax in-period
  (lambda () #'in-period/proc)
  (lambda (stx)
    (syntax-case stx ()
      [[(v) (_ from to elems)]
       #'[(v)
          (:do-in
           ([(a) from] [(b) to] [(n) elems])
           (unless (exact-positive-integer? n)
             (raise-type-error 'in-period "exact non-negative integer" n))
           ([i 0])
           (< i n)
           ([(v) (+ a (/ (* i (- b a)) n))])
           #true
           #true
           ((+ i 1)))]])))

(define (in-period/proc a b n)
  (for/list ([t (in-period a b n)])
    t))

(provide map-in-interval map-in-period)

(define map-in-interval
  (case-lambda
    ((f t0 t1 n)
     (for/list ((t (in-interval t0 t1 n)))
       (f t)))
    ((f u0 u1 nu v0 v1 nv)
     (for/list ((u (in-interval u0 u1 nu)))
       (for/list ((v (in-interval v0 v1 nv)))
         (f u v))))))

(define map-in-period
  (case-lambda
    ((f t0 t1 n)
     (for/list ((t (in-period t0 t1 n)))
       (f t)))
    ((f u0 u1 nu v0 v1 nv)
     (for/list ((u (in-period u0 u1 nu)))
       (for/list ((v (in-period v0 v1 nv)))
         (f u v))))))

;;HACK: highly inneficient
;; (define-syntax (for/append stx)
;;   (syntax-case stx ()
;;     [(_ clauses . defs+exprs)
;;      (with-syntax ([original stx])
;;        #'(for/fold/derived
;;           original
;;           ([r (list)]) clauses
;;           (values (append r (let () . defs+exprs))))])))

(define (singleton? l)
  (and (not (null? l))
       (null? (cdr l))))

(define (singleton-value l)
  (if (singleton? l)
      (car l)
      (error 'singleton-value "Not a singleton ~A" l)))

(provide asinh acosh atanh)
(define (asinh x)
  (log (+ x (sqrt (+ (* x x) 1)))))

(define (acosh x)
  (log (+ x (sqrt (- (* x x) 1)))))

(define (atanh x)
  (if (< (abs x) 1)
    (/ (log (/ (+ 1 x) (- 1 x))) 2)
    (/ (log (/ (+ x 1) (- x 1))) 2)))
         
(struct backend (name)
  #:property
  prop:custom-write (lambda (b port mode)
                      (fprintf port "#<~a>" (backend-name b))))

;;Available backends
(provide autocad rhino opengl tikz delayed)

(define autocad (backend "AutoCAD"))
(define rhino (backend "Rhinoceros"))
(define tikz (backend "TikZ"))
(define opengl (backend "OpenGL"))

;;The delayed backend constructs delayed
;;shapes, to be instantiated later in a
;;concrete backend.
(define delayed (backend "Unknown"))

;;The current out backend is the one active at
;;a given moment, used only during shape creation
(provide current-out-backend)
(define current-out-backend (make-parameter delayed))

;;The current in backend is the one active at
;;a given moment, used only during shape acquisition
(provide current-in-backend)
(define current-in-backend (make-parameter delayed))

;;Each shape is represented by a structure that contains 
;;the name of the shape, the backend that was used for
;;the creation, and an opaque value representing the actual
;;shape in that backend.

(struct shape ([name #:mutable] [backend #:mutable] [ref #:mutable] id [deleted? #:mutable])
  #:property prop:custom-write (lambda (s port mode)
                                 (fprintf port "#<~A~A ~A>" 
                                          (if (shape-deleted? s) "deleted " "")
                                          (shape-name s)
                                          (shape-id s))))

(define incr (let ((counter -1))
               (lambda ()
                 (set! counter (+ counter 1))
                 counter)))

(define (new-shape name backend ref)
  (if (shape? ref)
      (let ((base-name (shape-name ref)))
        (let ((name (cons name (if (list? base-name) base-name (list base-name)))))
          (shape name backend (shape-ref ref) (incr) #f)))
      (shape name backend ref (incr) #f)))
  
;;There are two modes of operation:
;;1. Immediate mode: Each operation causes immediate action on the current-out-backend
;;2. Delayed mode: Uses the delayed backend and a special print that realizes shapes.
(provide delayed-mode?)
(define delayed-mode? (make-parameter #f))

;;For the delayed backend, we also store
;;the function and args needed for reconstructing the
;;shape whenever necessary.

(struct delayed-shape shape (fn args)); [tm #:auto])
  ;#:auto-value #f #;m-identity)

;;That's the job of the realize function

(provide realize)
(define (realize v)
  (cond ((pair? v)
         (cons (realize (car v))
               (realize (cdr v))))
        ((delayed-shape? v)
         ;(printf "Shape: ~a ref:~a~%" v (shape-ref v))
         (when (shape-deleted? v) ;;nuke the previous reference
           (set-shape-ref! v #f))
         (unless (shape-ref v)
           (let ((realization
                  (apply (delayed-shape-fn v)
                         (map realize (delayed-shape-args v)))))
             ;;There are various options here:
             ;;1. Preserve the backend, so that operations can still access the original values
             ;(set-shape-ref! v realization)
             ;;2. Use the realization backend (and ref) so that operations use the realization backend
             (set-shape-ref! v (shape-ref realization))
             (set-shape-backend! v (shape-backend realization))))
         v)
        (else
         v)))

;;The realize function is called whenever we try to visualize
;;(print, in Racket terms) the delayed shape
(define default-current-print (current-print))

(define (rosetta-print value)
  (default-current-print
    (parameterize ((delayed-mode? #f))
      (realize value))))

(provide immediate-mode)
(define (immediate-mode)
  (delayed-mode? #f)
  (current-print default-current-print))

(provide delayed-mode)
(define (delayed-mode)
  (delayed-mode? #t)
  (current-print rosetta-print))

;;Some backends cannot compute certain intermediate 
;;shapes, although they can compute the final shape

;;As a simple example, consider three spheres A, B, 
;;and C, where C touches A and B, but A and B do not
;;touch each other.  Any CAD will compute (A U C) U B,
;;but some will fail at (A U B) U C.

;;For those cases, we use (for the lack of a better
;;name) "failed" shapes.

(define-for-syntax (build-name id fmt)
  (format-id id #:source id fmt (syntax-e id)))

(define-syntax (define-failed-operation stx)
  (syntax-case stx ()
    ((_ name)
     (with-syntax ([failed-name (build-name #'name "failed-~A")]
                   [delayed-name (build-name #'name "delayed-~A")]
                   [delayed-name? (build-name #'name "delayed-~A?")]
                   [pred-name (build-name #'name "failed-~A?")])
       #'(begin
           ;(struct delayed-name delayed-shape ())
           (define (failed-name subshapes)
             (if (null? subshapes)
                 (empty-shape);;HACK: This is only valid for unions. Intersection should
                 ;;probably use the universal-shape. And for subtractions I don't even 
                 ;;know what to use.
                 (if (null? (cdr subshapes))
                     (car subshapes)
                     (#;delayed-name
                      delayed-shape 'delayed-name #;'failed-name
                      (shape-backend (car subshapes))
                      #f
                      (incr)
                      #f
                      name
                      subshapes))))
           (define (pred-name s)
             (eq? (shape-name s) 'delayed-name #;'failed-name)))))))

(define-failed-operation intersection)
(define-failed-operation union)
(define-failed-operation subtraction)

(define (failed-operation? s)
  (or (failed-union? s)
      (failed-intersection? s)
      (failed-subtraction? s)))

(define failed-operation-shapes delayed-shape-args)

(define (unfailed-operation-name name)
  (case name
    ((delayed-intersection) 'intersection)
    ((delayed-union) 'union)
    ((delayed-subtraction) 'subtraction)))

(define (map-failed-operation f s)
  (cond ((null? s)
         null)
        ((pair? s)
         (cons (map-failed-operation f (car s))
               (map-failed-operation f (cdr s))))
        ((failed-operation? s)
         (struct-copy 
          delayed-shape
          s
          [args (map-failed-operation f (failed-operation-shapes s))]))
        (else
         (f s))))

;;To iterate among the tree of shapes

(define (for-each-shape f s)
  (cond ((null? s)
         #f)
        ((pair? s)
         (for-each-shape f (car s))
         (for-each-shape f (cdr s)))
        (else
         (f s))))

;;To map among the tree of shapes
(define (map-shape f s)
  (cond ((null? s)
         null)
        ((pair? s)
         (cons (map-shape f (car s))
               (map-shape f (cdr s))))
        (else
         (f s))))

;;To collect all shapes
(define (collect-all-shapes s)
  (let ((shapes (list)))
    (define (collect s)
      (cond ((or (empty-shape? s) (universal-shape? s))
             s)
            ((failed-operation? s)
             (for-each-shape collect (shape-ref s)))
            (else
             (set! shapes (cons s shapes)))))
    (for-each-shape collect s)
    shapes))


;;To obtain the backend of a tree of shapes
;;Note: In the future, it might be good to check
;;that all shapes have the same backend
(define (shapes-backend s)
  (cond ((shape? s)
         (shape-backend s))
        ((pair? s)
         (shapes-backend (car s)))
        (else
         (error "Can't identify the backend from" s))))


;;To access the shape opaque representation in the backend
;;we might need to resolve failed operations

(define (shape-impl s)
  (if (failed-operation? s)
      (let ((r (resolve s)))
        (set-shape-name! s (unfailed-operation-name (shape-name s)))
        (set-shape-ref! s r)
        r)
      (shape-ref s)))

(provide actual-shape)
(define (actual-shape s)
  (shape-impl s)
  s)

#|

We frequently need to unwrap shapes. Let's define
some syntax for that:

|#

(define-syntax (let-shapes stx)
  (syntax-case stx ()
    ((_ ((s e) ...) body ...)
     #'(let ((s (shape-impl e)) ...)
         body ...))))

#|

Definition of backend operations

|#

(define debug-backend (make-parameter #f))
(provide debug-backend)

;;The most generic
(define-syntax (case-backend stx)
  (syntax-case stx ()
    ((case-backend expr name clause ...)
     (syntax/loc stx
       (let ((backend expr))
         (case-backend* backend name clause ...))))))

(define-syntax (case-backend* stx)
  (syntax-case stx (else)  ;;In the future, optimize this with a jump table
    ((_ b name)
     (syntax/loc stx
       #;(printf "operation ~a not available in backend ~a~%" 'name b)
       (error 'name "operation not available in backend ~a" b)
       ))
    ((_ b name (else body ...))
     (syntax/loc stx
       (begin body ...)))
    ((_ b name ((backend ...) body ...) clause ...)
     (syntax/loc stx
       (if (or (eq? b backend) ...)
           (begin body ...)
           (case-backend* b name clause ...))))
    ((_ b name (backend body ...) clause ...)
     (syntax/loc stx
       (case-backend* b name ((backend) body ...) clause ...)))))

;;Using the current-out-backend
(define-syntax (case-current-backend stx)
  (syntax-case stx ()
    ((_ name clause ...)
     (syntax/loc stx
       (case-backend (current-out-backend) name clause ...)))))

;;Using a shape
(define-syntax (case-shape-backend stx)
  (syntax-case stx ()
    ((_ expr name clause ...)
     (syntax/loc stx
       (case-backend (shapes-backend expr) name clause ...)))))

(define-for-syntax (without-defaults params)
  (map (lambda (param)
         (let ((datum (syntax-e param)))
           (if (pair? datum)
               (car datum)
               param)))
       (syntax->list params)))

;;We also provide some combinations between function definition
;;and case-backend.

(define-syntax (def-backend-op stx)
  (syntax-case stx ()
    ((_ (name param ...) backend-expr clause ...)
     (with-syntax ([(arg ...) (without-defaults #'(param ...))])
       (syntax/loc stx
         (begin
           (provide name)
           (define (name param ...)
             (case-backend backend-expr name clause ...))))))))

(define-syntax (def-current-backend-op stx)
  (syntax-case stx ()
    ((_ (name arg ...) clause ...)
     (syntax/loc stx
       (def-backend-op (name arg ...) (current-out-backend) clause ...)))))

(define-syntax (def-shape-arg-op stx)
  (syntax-case stx ()
    ((_ (name arg0 arg1 ...) arg clause ...)
     (syntax/loc stx
       (def-backend-op (name arg0 arg1 ...) (shapes-backend arg) clause ...)))))

(define-syntax (def-shape-op stx)
  (syntax-case stx ()
    ((_ (name arg0 arg1 ...) clause ...)
     (syntax/loc stx
       (def-backend-op (name arg0 arg1 ...) (shapes-backend arg0) clause ...)))))

(define-syntax (def-new-shape stx)
  (syntax-case stx ()
    ((_ ((name shape backend-expr) param ...) clause ...)
     (with-syntax ([(arg ...) (without-defaults #'(param ...))]
                   [struct-name (build-name #'shape "delayed-~A")]
                   [pred-name (build-name #'shape "~A?")])
       (syntax/loc stx
         (begin
           (provide name)
           (struct struct-name delayed-shape (arg ...))
           (define (name param ...)
             (if (delayed-mode?)
                 (struct-name 'shape delayed #f (incr) #f name (list arg ...) arg ...)
                 (let ((backend backend-expr))
                   (new-shape 'shape backend 
                              (case-backend* backend
                                             name
                                             clause ...)))))
           (provide pred-name)
           (define (pred-name s)
             (if (list? (shape-name s))
                 (and (memq 'shape (shape-name s)) #t)
                 (eq? (shape-name s) 'shape)))))))
    ((def ((name shape-name) param ...) clause ...)
     (syntax/loc stx
       (def ((name shape-name (current-out-backend)) param ...) clause ...)))
    ((def (name param ...) clause ...)
     (syntax/loc stx
       (def ((name name) param ...) clause ...)))))

(define-syntax (def-new-shape-op stx)
  (syntax-case stx ()
    ((def ((name shape-name) arg0 arg1 ...) clause ...)
     (syntax/loc stx
       (def ((name shape-name (shapes-backend arg0)) arg0 arg1 ...) clause ...)))
    ((def ((name shape-name backend-expr) arg0 arg1 ...) clause ...)
     (syntax/loc stx
       (def-new-shape ((name shape-name backend-expr) arg0 arg1 ...)
         clause ...)))
    ((def (name arg0 arg1 ...) clause ...)
     (syntax/loc stx
       (def ((name name) arg0 arg1 ...) clause ...)))))

(define-syntax (def-new-shape* stx)
  (syntax-case stx ()
    ((_ (name arg0 arg1 ...) clause ...)
     (with-syntax ([name* (build-name #'name "~A*")])
       (syntax/loc stx
         (begin
           (def-list-arg name name*)
           (def-new-shape ((name* name) arg0 arg1 ...)
             clause ...)))))))

(define-syntax (def-new-shape-op* stx)
  (syntax-case stx ()
    ((_ (name arg0 arg1 ...) clause ...)
     (with-syntax ([name* (build-name #'name "~A*")])
       (syntax/loc stx
         (begin
           (def-list-arg name name*)
           (def-new-shape-op ((name* name) arg0 arg1 ...)
             clause ...)))))))

#|

Syntax for defining backend operations:

* If the operation depends _only_ on the current-out-backend,
use:

(def-current-backend-op (name arg ...)
  (rhino
    expr ...)
  (autocad
    expr ...)
  ...)

* If the operation depends on a computed backend, use:

(def-backend-op (name arg ...)
  expression-that-evaluates-to-backend
  (rhino
    expr ...)
  (autocad
    expr ...)
  ...)

For example:
    
(def-backend-op (sweep path shape)
  (if (monday?) rhino autocad)
  (rhino
    expr ...)
  (autocad
    expr ...)
  ...)

* If the backend to use is the one stored in an
arg shape, i.e., the expression that evaluates to 
a backend is the result of (shape-backend arg), use:

(def-shape-arg-op (name arg ...)
  arg
  (rhino
    expr ...)
  (autocad
    expr ...)
  ...)

* If the backend to use comes from the first shape arg, use:

(def-shape-op (name arg ...)
  (rhino
    expr ...)
  (autocad
    expr ...)
  ...)

* If the backend to use comes from the first shape arg _and_
the result must be wrapped in a shape that saves the backend
used, use:

(def-new-shape-op (name arg ...)
  (rhino
    expr)
  (autocad
    expr)
  ...)

* If the backend to use is the current-out-backend _and_
the result must be wrapped in a shape that saves the backend
used, use:

(def-new-shape (name arg ...)
  (rhino
    expr)
  (autocad
    expr)
  ...)

or, in case you want to use a specific name for the shape
which doesn't match the function name:

(def-new-shape ((name shape-name) arg ...)
  (rhino
    expr)
  (autocad
    expr)
  ...)

* If the shape constructor accepts either a variable
number of arguments or a list of arguments plus some
additional arguments, use:

(def-new-shape* (name arg ...)
  (rhino
    expr)
  (autocad
    expr)
  ...)

If your were paying attention, you noticed that there's a
missing operation: def-new-shape-shape-arg-op. If the need
arises, we will provide it but it doesn look like we will 
need it.

|#

;;Choose backend
(provide select-backend)
(define (select-backend backend [op 'none])
  (in-out-backend backend backend op))

(provide in-out-backend)
(define (in-out-backend in [out in] [op 'none])
  (current-in-backend in)
  (current-out-backend out)
  (start-backend in)
  (unless (eq? in out)
    (start-backend out))
  (case op
    [(none) (void)]
    [(delete)
     (delete-all-shapes)
     (void)])
  #;(delayed-mode)
  (immediate-mode))

(define (start-backend backend)
  (case-backend 
   backend start-backend
   (delayed
    #t)
   (rhino
    (rh:load-rhino-com)
    #t)
   (autocad
    (ac:load-autocad-com)
    (ac:reset-ucs)
    (ac:delobj 0)
    (ac:osmode 0)
    
    ;(ac:nomutt 1)
    ;(ac:cmdecho 0)
    ;(ac:expert 5)
    
    ;(ac:objectsnap)
    ;(ac:surfaceassociativity 0)
    ;(ac:surfacemodelingmode 1)
    ;(ac:solidhist 0)

    ;(ac:start-undo-mark)
    (ac:undo-off)
    #t)
   (opengl
    (gl:load-opengl))
   (tikz
    ;;Don't need to do anything
    #t)))
  
(def-current-backend-op (all-shapes)
  (rhino
   (map rh:shape<-ref (rh:all-objects)))
  (autocad
   (map ac:shape<-ref (ac:all-objects)))
  (opengl
   (map gl:shape<-ref (gl:all-actors))))

(def-current-backend-op (delete-all-shapes)
  (rhino
   (rh:delete-objects (rh:all-objects)))
  (autocad
   (ac:erase-all))
  (opengl
   (gl:erase-all-actors))
  (tikz
   ;;Nothing to do here
   #t))

;;To accept a variable number of arguments

(define-syntax (def-var-args stx)
  (syntax-case stx ()
    ((_ name name2)
     #'(begin
         (provide name)
         (define (name c . cs)
           (name2 (if (null? cs) c (cons c cs))))))))

;;To accept a list of arguments or a variable number of arguments
(define-syntax (def-list-arg stx)
  (syntax-case stx ()
    ((_ name name2)
     #'(begin
         (provide name)
         (define (name c . cs)
           (if (list? c)
               (apply name2 c cs)
               (name2 (cons c cs))))))))

;;We also need some mathematically special shapes that represent empty sets or universal sets

(define the-empty-shape (shape 'empty delayed #f "shape" #f))
(define the-universal-shape (shape 'universal delayed #f "shape" #f))

(provide empty-shape empty-shape?)
(define (empty-shape) the-empty-shape)
(define (empty-shape? s) (eq? s the-empty-shape))

(provide universal-shape universal-shape)
(define (universal-shape) the-universal-shape)
(define (universal-shape? s) (eq? s the-universal-shape))

#|

The actual operations:

|#

(define (transform-from transform ref c)
  (transform 
   (transform ref
              (let ((tr (tr-matrix (position-cs (as-origin c)))))
                (m-cols (m-column tr 0)
                        (m-column tr 1)
                        (m-column tr 2)
                        (vector 0 0 0 1))))
   (m-translation (as-world c))))

(define (ac:transform-from com c)
  (transform-from ac:transform com c))

(define (gl:transform-from actor c)
  (transform-from gl:transform actor c))


;;No longer needed. The predicates are automatically defined
;;and operate on the rosetta side.
;(def-shape-op (point? p)
;  (delayed
;   (delayed-point? p))
;  (rhino
;   (let-shapes ((p p))
;     (rh:is-point p)))
;  (autocad
;   (let-shapes ((p p))
;     (ac:point? p))))
;
;(def-shape-op (circle? c)
;  (rhino
;   (let-shapes ((c c))
;     (rh:is-circle c)))
;  (autocad
;   (let-shapes ((c c))
;     (ac:circle? c))))
;
;
;(def-shape-op (ellipse? shape)
;  (rhino
;   (rh:is-ellipse (shape-impl shape)))
;  (autocad
;   (ac:ellipse? (shape-impl shape))))
;
;
;(def-shape-op (line? shape)
;  (rhino
;   (let-shapes ((r shape))
;    (or (rh:is-line r)
;        (rh:is-polyline r))))
;  (autocad
;   (let-shapes ((r shape))
;    (or (ac:3d-polyline? r)
;        (ac:2d-polyline? r)
;        (ac:line? r)
;        (ac:lightweight-polyline? r)))))
;
;
;(def-shape-op (closed-line? shape)
;  (rhino
;   (let-shapes ((r shape))
;    (and (rh:is-curve r)
;         (rh:is-curve-closed r))))
;  (autocad
;   (let-shapes ((r shape))
;    (and (or (ac:3d-polyline? r)
;             (ac:2d-polyline? r)
;             (ac:line? r)
;             (ac:lightweight-polyline? r))
;         (ac:closed r)))))
;
;
;(def-shape-op (curve? c)
;  (rhino
;   (let-shapes ((c c))
;     (rh:is-curve c)))
;  (autocad
;   (let-shapes ((c c))
;     (ac:curve? c))))
;

;; point

(def-new-shape (point position)
  (rhino
   (rh:add-point position))
  (autocad
   (ac:add-point position))
  (opengl
   (gl:add-point position)))

(def-shape-op (point-position p)
  (delayed
   (delayed-point-position p))
  (rhino
   (let-shapes ((p p))
     (rh:point-coordinates p)))
  (autocad
   (let-shapes ((p p))
     (car (ac:coordinates p))))
  (opengl
   (let-shapes ((p p))
     (gl:point-coordinates p))))

;; circle

(def-new-shape (circle [c u0] [r 1])
  (rhino
   (if (= r 0)
       (rh:add-point c)
       (rh:add-circle c r)))
  (autocad
   (if (= r 0)
       (ac:add-point c)
       (ac:transform-from
        (ac:add-circle u0 r)
        c)))
  (opengl
   (if (= r 0)
       (gl:add-point c)
       (gl:transform-from
        (gl:add-circle u0 r)
        c)))
  (tikz
   (if (= r 0)
       (tz:point c)
       (tz:circle c r))))

(def-shape-op (circle-radius c)
  (delayed
   (delayed-circle-r c))
  (rhino
   ;;HACK: should we do this or should we just always consult the information contained in the shape?
   ;;This last option would not work for shapes that came directly from the backend.
   (let-shapes ((c c))
     (if (rh:is-point c)
         0
         (rh:circle-radius c))))
  (autocad
   (let-shapes ((c c))
     (if (ac:point? c)
         0
         (ac:circle-radius c)))))

(def-shape-op (circle-center c)
  (delayed
   (delayed-circle-c c))
  (rhino
   (let-shapes ((c c))
     (if (rh:is-point c)
         (rh:point-coordinates c)
         (rh:circle-center-point c))))
  (autocad
   (let-shapes ((c c))
     (if (ac:point? c)
         (car (ac:coordinates c))
         (ac:center c)))))

(def-new-shape (surface-circle [c u0] [r 1])
  (rhino
   (if (= r 0)
       (rh:add-point c)
       (rh:add-surface-circle c r)))
  (autocad
   (if (= r 0)
       (ac:add-point c)
       (ac:add-surface-circle c r)))
  (opengl
   (if (= r 0)
       (gl:add-point c)
       (gl:transform-from
        (gl:add-surface-circle u0 r)
        c))))

(define (rh:add-surface-circle c r)
  (let ((circ (rh:add-circle c r)))
    (begin0
        (rh:singleton-id (rh:add-planar-srf circ))
      (rh:delete-object circ))))

(define (ac:add-surface-circle c r)
  (let ((circ (ac:add-circle c r)))
    (begin0
        (car (ac:add-region circ))
      (ac:delete circ))))

;; arc

(define (arc-morph c r beg-a a point circle)
  (cond ((= r 0)
         (point c))
        ((= a 0)
         (point (+pol c r beg-a)))
        ((>= (abs a) 2pi)
         (circle c r))
        (else
         #f)))

;;HACK the morph case doesn't seem to be correct because it doesn't respect the coordinate system of c
;;It also seems to prevent the use of primitives (e.g. gl:add-circle) that always create shapes at the
;;origin
(def-new-shape (arc [c u0] [r 1] [beg-a 0] [a pi])
  (rhino
   (or (arc-morph c r beg-a a rh:add-point rh:add-circle)
       (rh:add-arc
        (if (= beg-a 0)
            c
            (rh:rotate-plane c (radians->degrees beg-a) uz))
        r
        (radians->degrees (coterminal a)))))
  (autocad
   (let ((end-a (+ beg-a a)))
     (or (arc-morph c r beg-a a ac:add-point ac:add-circle)
         (ac:transform-from
          (if (> end-a beg-a)
              (ac:add-arc u0 r beg-a end-a)
              (ac:add-arc u0 r end-a beg-a))
          c))))
  (opengl
   (let ((end-a (+ beg-a a)))
     (or (arc-morph c r beg-a a gl:add-point gl:add-circle)
         (gl:transform-from
          (if (> end-a beg-a)
              (gl:add-arc u0 r beg-a end-a)
              (gl:add-arc u0 r end-a beg-a))
          c)))))


(define (surface-arc-morph c r beg-a a point line surface-circle)
  (cond ((= r 0)
         (point c))
        ((= a 0)
         (line c (+pol c r beg-a)))
        ((>= a 2pi)
         (surface-circle c r))
        (else
         #f)))

(def-new-shape (surface-arc [c u0] [r 1] [beg-a 0] [end-a pi])
  (rhino
   (let ((a (- beg-a end-a)))
     (or (surface-arc-morph c r beg-a a rh:add-point rh:add-line rh:add-surface-circle)
         (let ((curves
                (list (rh:add-arc
                       (if (= beg-a 0)
                           c
                           (rh:rotate-plane c (radians->degrees beg-a) uz))
                       r
                       (radians->degrees (coterminal a)))
                      (rh:add-line c (+pol c r beg-a))
                      (rh:add-line c (+pol c r end-a)))))
           (begin0
               (rh:singleton-id (rh:add-planar-srf curves))
             (rh:delete-objects curves))))))
  (autocad
   (or (arc-morph c r beg-a (- beg-a end-a) ac:add-point ac:add-surface-circle)
       (let ((curves
              (list (ac:transform-from
                     (if (> end-a beg-a)
                         (ac:add-arc u0 r beg-a end-a)
                         (ac:add-arc u0 r end-a beg-a))
                     c)
                    (ac:add-line c (+pol c r beg-a))
                    (ac:add-line c (+pol c r end-a)))))
         (begin0
           (car (ac:add-region curves))
           (for ((c (in-list curves))) (ac:delete c))))))
  (opengl
   (or (arc-morph c r beg-a (- beg-a end-a) gl:add-point gl:add-surface-circle)
       (gl:transform-from
        (if (> end-a beg-a)
            (gl:add-surface-arc u0 r beg-a end-a)
            (gl:add-surface-arc u0 r end-a beg-a))
        c))))

;; elliptical arc
#|
(define elliptical-arc
  (case-lambda
    ((x-r y-r angle)
     (elliptical-arc u0 x-r y-r angle))
    ((c x-r y-r angle)
     (elliptical-arc c x-r y-r 0 angle))
    ((c x-r y-r begin-angle end-angle)
     (move
      c
      (rotate-z
       begin-angle
       (elliptical-arc x-r y-r (- end-angle begin-angle)))))))

(def-new-shape (elliptical-arc x-radius y-radius angle)
  (rhino
   (scale (origin-scaling-type) (xyz x-radius y-radius 1) (arc 1 angle))))

|#

(define (ellipse-morph c xr yr)
  (cond ((= xr yr 0)
         (point c))
        ((= xr 0)
         (line (+y c (- yr)) (+y c yr)))
        ((= yr 0)
         (line (+x c (- xr)) (+x c xr)))
        (else
         #f)))

(def-new-shape (ellipse [c u0] [xr 1] [yr 1/2])
  (rhino
   (or (ellipse-morph c xr yr)
       (rh:add-ellipse c xr yr)))
  (autocad
   (or (ellipse-morph c xr yr)
       (ac:transform-from
        (if (> xr yr)
            (ac:add-ellipse u0 (xyz xr 0 0) (/ yr xr))
            (ac:add-ellipse u0 (xyz 0 yr 0) (/ xr yr)))
        c))))

(def-new-shape* (line cs)
  (rhino
   (rh:add-polyline cs))
  (autocad
   (ac:add-3d-poly cs))
  (opengl
   (gl:add-line #f cs))
  (tikz
   (tz:line cs)))

(def-shape-op (line-vertices l)
  (rhino
   (let-shapes ((r l))
     (let ((pts (rh:curve-points r)))
       (if (or (rh:is-curve-closed r)
               (< (distance (car pts) (last pts)) 1.0e-15)) ;Rhino tolerance
           (drop-right pts 1)
           pts))))
  (autocad
   (let-shapes ((r l))
     (let ((pts
            (cond ((ac:line? r)
                   (list (ac:start-point r) (ac:end-point r)))
                  ((ac:lightweight-polyline? r) ;;This is not right, we need to convert coordinates
                   (let ((h (ac:elevation r)))
                     (map (lambda (p) (+z p h)) (ac:2d-coordinates r))))
                  ((ac:3d-polyline? r)
                   (ac:coordinates r))
                  (else
                   (error 'line-vertices "Can't compute vertices of ~A" l)))))
       (if (or (ac:closed r)
               (< (distance (car pts) (last pts)) 1.0e-015)) ;AutoCAD tolerance
           (drop-right pts 1)
           pts)))))

#|
 
; predicates

(define (angle? a)
  (number? a))

(define (distance? d)
  (and (number? d) (positive? d)))

(define (nonnegative-number? r)
  (and (number? r) (not (negative? r))))

(define (nonnegative-integer? r)
  (and (integer? r) (not (negative? r))))

(define (coord-list? lst)
  (and (list? lst) (every is-coord lst)))

(define (node? expr)
  (is-a? expr node%))

; elliptical-arc

(define (elliptical-arc-impl angle x-radius y-radius)
  (assert-types 'elliptical-arc-impl (list number? nonnegative-number? nonnegative-number?) (list angle x-radius y-radius))
  (cond ((= x-radius y-radius) (arc x-radius angle))
        ((= x-radius 0) (line u0 (y y-radius))) ; edit: depends on the angle
        ((= y-radius 0) (line u0 (x x-radius))) ; edit: depends on the angle
        ((= angle 0) (point (x x-radius)))
        (else
         (let ((angle (coterminal angle)))
           (if (= angle 0)
               (ellipse x-radius y-radius)
               (new elliptical-arc-node% (angle angle) (x-radius x-radius) (y-radius y-radius)))))))

(define elliptical-arc
  (case-lambda
    ((x-r y-r angle)
     (elliptical-arc-impl angle x-r y-r))
    ((c x-r y-r angle)
     (move
      c
      (elliptical-arc x-r y-r angle)))
    ((c x-r y-r begin-angle end-angle)
     (move
      c
      (rotate-z
       begin-angle
       (elliptical-arc x-r y-r (- end-angle begin-angle)))))))

; /elliptical-arc

|#

;HACK This should be applicable to empty-shapes
(def-shape-op (bounding-box s)
  (rhino
   (rh:bounding-box (shape-impl s)))
  (autocad
   (ac:bounding-box (shape-impl s)))
  (opengl
   (gl:bounding-box (shape-impl s))))

(def-new-shape-op (closed shape)
  (else
   (begin0
       (error 'closed "Finish this. Dispatch on shape type and create closed shape"))))

(def-new-shape* (closed-line cs)   
  (rhino
   (let ((id (rh:add-polyline (append cs (list (car cs))))))
     ;; (cond ((rh:is-curve-closed id)
     ;;        id)
     ;;       ((rh:is-curve-closable id)
     ;;        (rh:close-curve id))
     ;;       (else
     ;;         (delete-object id)
     ;;         (add-polyline (append-first coords)))))
     id))
  (autocad
   (let ((com (ac:add-3d-poly (append cs (list (car cs))))))
     (ac:closed com #t)
     com))
  (opengl
   (gl:add-line #t (map as-world cs)))
  (tikz
   (tz:closed-line (map as-world cs))))


(def-new-shape* (spline cs [v0 #f] [v1 #f])
  (rhino
   (rh:add-interp-curve-ex
    cs
    3
    rh:knot-style-chord-length-spacing
    #t
    (or v0 rh:com-omit)
    (or v1 rh:com-omit)))
  (autocad
   ;;HACK: apparently, there's no difference
   ;(ac:spline-command cs v0 v1)
   (let ((v0 (or v0 (-c (cadr cs) (car cs))))
         (v1 (or v1 
                 (let ((end (take-right cs 2)))
                   (-c (cadr end) (car end))))))
     (ac:add-spline cs v0 v1)))
  (opengl
   (gl:add-spline #f cs v0 v1)))

(def-new-shape* (closed-spline cs [v0 #f] [v1 #f])
  (rhino
   (rh:add-interp-curve-ex
    (append cs (list (car cs)))
    3
    rh:knot-style-chord-length-spacing
    #f
    (or v0 rh:com-omit)
    (or v1 rh:com-omit)))
  (autocad
   (spline (append cs (list (car cs))) v0 v1)) ;;HACK SHOULDN'T WE CLOSED THIS?
  (opengl
   (gl:add-spline #t cs v0 v1)))



;;A polygon should have all its vertices in the same plane
;;but we don't check that
(def-new-shape* (polygon cs)
  (else
   (closed-line cs)))

(def-new-shape* (surface-polygon cs)
  (rhino
   (let ((id (rh:add-polyline (append cs (list (car cs))))))
     (begin0
         (rh:singleton-id (rh:add-planar-srf id))
       (rh:delete-object id))))
  (autocad
   (let ((com (ac:add-3d-poly (append cs (list (car cs))))))
     (ac:closed com #t)
     (begin0
         (car (ac:add-region com))
       (ac:delete com))))
  (opengl
   (gl:add-surface-from-points 
    (map as-world (append cs (list (car cs)))))))

(provide regular-polygon-vertices)
(define (regular-polygon-vertices edges [c u0] [r 1] [a 0] [inscribed? #f])
  (let ((r (if inscribed? r (/ r (cos (/ pi edges)))))) ;;from inscribed to circumscribed 
    (for/list ((a (in-period a (+ a 2pi) edges)))
      (+pol c r a))))

(def-new-shape (regular-polygon edges [c u0] [r 1] [a 0] [inscribed? #f])
  (else
   (if (= r 0)
       (point c)
       (polygon (regular-polygon-vertices edges c r a inscribed?)))))

(def-new-shape (surface-regular-polygon edges [c u0] [r 1] [a 0] [inscribed? #f])
  (opengl
   (gl:add-surface-from-points-pivot
    (regular-polygon-vertices edges c r a inscribed?)
    c))
  (else
   (surface (regular-polygon edges c r a inscribed?))))

;; rectangle

(define (rectangle-morph c dx dy point line)
  (cond ((= dx dy 0)
         (point c))
        ((= dx 0)
         (line c (+y c dy)))
        ((= dy 0)
         (line c (+x c dx)))
        (else
         #f)))

(define (rectangle-deltas c dx/c1 dy)
  (if (number? dx/c1)
      (values dx/c1 dy)
      (let ((d (-c dx/c1 c)))
        (values (xyz-x d) (xyz-y d)))))

(def-new-shape (rectangle [c u0] [dx/c1 1] [dy 1])
  (rhino
   (let-values ([(dx dy) (rectangle-deltas c dx/c1 dy)])
     (or (rectangle-morph c dx dy rh:add-point rh:add-line)
         (rh:add-polyline (list c (+x c dx) (+xy c dx dy) (+y c dy) c)))))
  (autocad
   (let-values ([(dx dy) (rectangle-deltas c dx/c1 dy)])
     (or (rectangle-morph c dx dy ac:add-point ac:add-line)
         (ac:add-3d-poly (list c (+x c dx) (+xy c dx dy) (+y c dy) c))
         #;(ac:transform-from
            (ac:add-polyline (list u0 (x dx) (xy dx dy) (y dy) u0)) ;;Using polylines because 
            ;;3d-poly does not support offset 
            c))))
  (opengl
   (let-values ([(dx dy) (rectangle-deltas c dx/c1 dy)])
     (or (rectangle-morph c dx dy gl:add-point gl:add-line)
         (gl:add-rectangle c dx dy))))
  (tikz
   (let-values ([(dx dy) (rectangle-deltas c dx/c1 dy)])
     (or (rectangle-morph c dx dy tz:point tz:line)
         (tz:rectangle c dx dy)))))

(def-new-shape (surface-rectangle [c u0] [dx/c1 1] [dy 1])
  (rhino
   (let-values ([(dx dy) (rectangle-deltas c dx/c1 dy)])
     (or (rectangle-morph c dx dy rh:add-point rh:add-line)
         (let ((rect (rh:add-polyline (list c (+x c dx) (+xy c dx dy) (+y c dy) c))))
           (begin0
               (rh:singleton-id (rh:add-planar-srf rect))
             (rh:delete-object rect))))))
  (autocad
   (let-values ([(dx dy) (rectangle-deltas c dx/c1 dy)])
     (or (rectangle-morph c dx dy ac:add-point ac:add-line)
         (let ((rect (ac:add-3d-poly (list c (+x c dx) (+xy c dx dy) (+y c dy) c))))
           (begin0
               (ac:singleton-or-union
                (ac:add-region (list rect)))
             (ac:delete rect))))))
  (opengl
   (let-values ([(dx dy) (rectangle-deltas c dx/c1 dy)])
     (or (rectangle-morph c dx dy gl:add-point gl:add-line)
         (gl:add-surface-from-points 
          (list c (+x c dx) (+xy c dx dy) (+y c dy) c))))))

(provide show-position)
(define (show-position p)
  (let ((cs (position-cs p)))
    (list (cylinder (cs-o cs) 0.01 (+c (cs-o cs) (cs-x cs)))
          (cylinder (cs-o cs) 0.01 (+c (cs-o cs) (cs-y cs)))
          (cylinder (cs-o cs) 0.02 (+c (cs-o cs) (cs-z cs)))
          (list (sphere (as-world p) 0.03))))
  p)

; text

(def-new-shape (text str [c u0] [h 1])
  (rhino
   (rh:add-text str c h))
  (autocad
   (ac:transform-from (ac:add-text str u0 h) c))
  (opengl
   (gl:transform-from (gl:add-text str u0 h) c))
  (tikz
   (tz:text str c h)))

(def-new-shape (text-centered str [c u0] [h 1])
  (else
   (text str (+xy c (/ (text-length str h) -2) (/ h -2)) h)))

(def-current-backend-op (text-length str [h 1])
  (else
   ;;HACK conservative approach
   (* (string-length str) h 0.7)))

; solids

(def-new-shape (sphere [c u0] [r 1])
  (autocad
   (ac:add-sphere c r))
  (rhino
   (rh:add-sphere c r))
  (opengl
   (gl:add-sphere c r)))

(def-shape-op (sphere-center s)
  (delayed
   (delayed-sphere-c s))
#;  (rhino ;Doesn't exist
   (rh:sphere-center s)))

(def-shape-op (sphere-radius s)
  (delayed
   (delayed-sphere-r s))
#;  (rhino ;Doesn't exist
   (rh:sphere-radius s)))


(def-new-shape (torus [c u0] [re 1] [ri 1/2])
  (rhino
   (rh:add-torus2 c re ri))
  (autocad
   (ac:transform-from (ac:add-torus u0 re ri) c))
  (opengl
   (gl:transform-from (gl:add-torus u0 re ri) c)))


(def-new-shape (regular-pyramid-frustum [edges 4] [cb u0] [rb 1] [a 0] [h/ct 1] [rt 1] [inscribed? #f])
  (opengl
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c (max rb rt) h
                      point
                      (lambda (c r) (surface-regular-polygon edges c r a inscribed?))
                      line)
         (gl:transform (if (= rt 0)
                           (gl:add-pyramid u0 rb h a edges)
                           (gl:add-pyramid-frustum u0 rb rt h a edges))
                       (tr-matrix (position-cs (as-origin c)))))))   
  (else
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c (max rb rt) h
                      point
                      (lambda (c r) (surface-regular-polygon edges c r a inscribed?))
                      line)
         (loft ;;don't use loft-curves because one of the polygons might be degenerate
          (list (regular-polygon edges c rb a inscribed?)
                (regular-polygon edges (+z c h) rt a inscribed?))
          #t
          #t)))))

(def-new-shape (regular-pyramid [edges 4] [cb u0] [rb 1] [a 0] [h/ct 1] [inscribed? #f])
  ((rhino autocad)
   (regular-pyramid-frustum edges cb rb a h/ct 0 inscribed?))
  (opengl
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c rb h gl:add-point gl:add-circle gl:add-line) ;;HACK circle? WRONG!
         (gl:transform (gl:add-pyramid u0 rb h a edges)
                       (tr-matrix (position-cs (as-origin c))))))))

(def-new-shape (irregular-pyramid pts ct [solid? #t])
  (else
   (loft-curve-point (polygon pts) (point ct) solid?)))

(def-new-shape (regular-prism edges [cb u0] [r 1] [a 0] [h/ct 1])
  (else
   (regular-pyramid-frustum edges cb r a h/ct r)))

(def-new-shape (irregular-prism cbs [h/ct 1] [solid? #t])
  (else
   (let ((v (if (number? h/ct) (z h/ct) h/ct)))
     (loft-curves
      (list (polygon cbs)
            (polygon (map (lambda (p) (+c p v)) cbs)))
      #t
      solid?))))

(def-new-shape (right-cuboid [cb u0] [width 1] [height 1] [h/ct 1])
  (else
   (let-values ([(c h) (position-and-height cb h/ct)])
     (irregular-prism
      (list (+xy c (/ width -2) (/ height -2))
            (+xy c (/ width +2) (/ height -2))
            (+xy c (/ width +2) (/ height +2))
            (+xy c (/ width -2) (/ height +2)))
      h))))
; box

(define (box-morph c dx dy dz point line rectangle)
  (cond ((= dx dy dz 0)
         (point c))
        ((= dx dy 0)
         (line c (+z c dz)))
        ((= dx dz 0)
         (line c (+y c dy)))
        ((= dy dz 0)
         (line c (+x c dx)))
         ; ((= dx 0) (rectangle (line u0 (y dy)) (line u0 (z dz))) ; edit: not possible (yet?)
         ; ((= dy 0) (rectangle (line u0 (x dx)) (line u0 (z dz))) ; edit: not possible (yet?)
         ; ((= dz 0) (rectangle (line u0 (x dx)) (line u0 (y dy))) ; edit: not possible (yet?)
        (else
         #f)))

(define (box-deltas c dx/c1 dy dz)
  (if (number? dx/c1)
      (values dx/c1 dy dz)
      (let ((d (-c dx/c1 c)))
        (values (xyz-x d) (xyz-y d) (xyz-z d)))))

(def-new-shape (box [c u0] [dx/c1 1] [dy (if (number? dx/c1) dx/c1 1)] [dz dy])
  (rhino
   (let-values ([(dx dy dz) (box-deltas c dx/c1 dy dz)])
     (or (box-morph c dx dy dz rh:add-point rh:add-line #f)
         (rh:add-box
          (list c
                (+x c dx)
                (+xy c dx dy)
                (+y c dy)
                (+z c dz)
                (+xz c dx dz)
                (+xyz c dx dy dz)
                (+yz c dy dz))))))
  (autocad
   (let-values ([(dx dy dz) (box-deltas c dx/c1 dy dz)])
     (or (box-morph c dx dy dz ac:add-point ac:add-line #f)
         (ac:transform-from (ac:add-box (xyz (/ dx 2) (/ dy 2) (/ dz 2))
                                        (abs dx) (abs dy) (abs dz))
                            c))))
  (opengl
   (let-values ([(dx dy dz) (box-deltas c dx/c1 dy dz)])
     (or (box-morph c dx dy dz gl:add-point gl:add-line #f)
         (gl:transform-from (gl:add-box (xyz (/ dx 2) (/ dy 2) (/ dz 2))
                                        (abs dx) (abs dy) (abs dz))
                            c)))))

(def-new-shape (cuboid b0 b1 b2 b3 t0 t1 t2 t3)
  (rhino
   (rh:add-box (list b0 b1 b2 b3 t0 t1 t2 t3))))


;; cone

(define (axial-morph c r l point circle line)
  (cond ((and (= l 0) (= r 0))
         (point c))
        ((= l 0)
         (circle c r))
        ((= r 0)
         (line c (+z c l)))
        (else
         #f)))

(def-new-shape (cone [cb u0] [r 1] [h/ct 1])
  (rhino
   (let-values ([(c h) (inverted-position-and-height cb h/ct)])
     (or (axial-morph cb r h rh:add-point rh:add-circle rh:add-line)
         (rh:add-cone-from-plane c h r))))
  (autocad
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c r h ac:add-point ac:add-circle ac:add-line)
         (ac:transform (ac:add-cone (+z u0 (/ h 2.0)) r h)
                       (tr-matrix (position-cs (as-origin c)))))))
  (opengl
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c r h ac:add-point ac:add-circle ac:add-line)
         (gl:transform (gl:add-cone u0 r h)
                       (tr-matrix (position-cs (as-origin c))))))))

; cone-frustum

(def-new-shape (cone-frustum [cb u0] [rb 1] [h/ct 1] [rt 1])
  (rhino
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c (max rb rt) h rh:add-point rh:add-circle rh:add-line)
         (let ((circs (list (rh:add-circle c rb) (rh:add-circle (+z c h) rt))))
           (let ((srf (rh:add-loft-srf circs rh:com-omit rh:com-omit rh:loft-type-straight)))
             (rh:capped-planar-holes srf)
             (rh:delete-objects circs)
             srf)))))
  (autocad
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c (max rb rt) h ac:add-point ac:add-circle ac:add-line)
         (ac:transform (ac:add-cone-frustum u0 rb rt h)
                       (tr-matrix (position-cs (as-origin c)))))))
  (opengl
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c (max rb rt) h ac:add-point ac:add-circle ac:add-line)
         (gl:transform (gl:add-cone-frustum u0 rb rt h)
                       (tr-matrix (position-cs (as-origin c))))))))

; cylinder

(def-new-shape (cylinder [cb u0] [r 1] [h/ct 1])
  (rhino
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c r h rh:add-point rh:add-circle rh:add-line)
         (rh:add-cylinder-from-plane c h r))))
  (autocad
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c r h ac:add-point ac:add-circle ac:add-line)
         (ac:transform (ac:add-cylinder (+z u0 (/ h 2.0)) r h)
                       (tr-matrix (position-cs (as-origin c)))))))
  (opengl
   (let-values ([(c h) (position-and-height cb h/ct)])
     (or (axial-morph c r h gl:add-point gl:add-circle gl:add-line)
         (gl:transform (gl:add-cylinder u0 r h)
                       (tr-matrix (position-cs (as-origin c))))))))


;; Predicates

; transformations
(define (contains-pivot? s)
  (or (circle? s)
      (arc? s))) ;;HACK what else?

#;
(def-new-shape-op (extrusion profile [dir 1])
  (rhino
   (begin0
       (rh:extrude (shape-impl profile)
                   (if (number? dir) (z dir) dir))
     (delete-shape profile)))
  (autocad
   (begin0
       (ac:singleton-or-union
        (if (number? dir)
            (ac:extrude-command-length (shape-impl profile) dir (surface-region? profile))
            (ac:extrude-command-direction (shape-impl profile) u0 dir (surface-region? profile))))
       ;; (if (number? dir)
       ;;     (ac:add-extruded-solid (shape-impl profile) dir)
       ;;     (let ((path (ac:add-line u0 dir)))
       ;;       (begin0
       ;;           (ac:add-extruded-solid-along-path (shape-impl profile) path)
       ;;         (ac:delete path))))
     (delete-shape profile)))
  (opengl
   (begin0
       (gl:add-extrusion (shape-impl profile)
                         (if (number? dir) (z dir) dir)
                         (surface-region? profile)
                         (contains-pivot? profile)
                         (smooth-curve? profile))
     (delete-shape profile))))

(provide extrusion)
(define (extrusion profile [dir 1])
  (map-failed-operation
   (lambda (profile)
     (if (empty-shape? profile)
         (empty-shape)
         (new-shape
          'extrusion
          (shape-backend profile)
          (case-shape-backend
           profile extrusion
           (rhino
            (begin0
              (rh:extrude (shape-impl profile)
                          (if (number? dir) (z dir) dir))
              (delete-shape profile)))
           (autocad
            (begin0
              (ac:singleton-or-union
               (if (number? dir)
                   (ac:extrude-command-length (shape-impl profile) dir (surface-region? profile))
                   (ac:extrude-command-direction (shape-impl profile) u0 dir (surface-region? profile))))
              ;; (if (number? dir)
             ;;     (ac:add-extruded-solid (shape-impl profile) dir)
              ;;     (let ((path (ac:add-line u0 dir)))
              ;;       (begin0
              ;;           (ac:add-extruded-solid-along-path (shape-impl profile) path)
              ;;         (ac:delete path))))
              (delete-shape profile)))
           (opengl
            (begin0
              (gl:add-extrusion (shape-impl profile)
                                (if (number? dir) (z dir) dir)
                                (surface-region? profile)
                                (contains-pivot? profile)
                                (smooth-curve? profile))
              (delete-shape profile)))))))
     profile))

(provide move)
(define (move shape v)
  (map-failed-operation
   (lambda (s)
     (case-shape-backend
      s move
      (rhino
       (rh:move-objects (shape-ref s) v)
       s)
      (autocad
       (ac:move (shape-ref s) u0 v)
       s)
      (opengl
       (gl:move (shape-ref s) v)
       s)))
   shape))

(provide mirror)
#;(define (mirror shape [p u0] [copy? #t])
  (if copy?
      (union (copy-shape shape)
             (mirror shape p #f))
      (map-failed-operation
       (lambda (s)
         (case-shape-backend
          s mirror
          (rhino
           (rh:mirror-object (shape-ref s) p (+x p 1) #f)
           s)
          (autocad
           (begin0
               (new-shape (shape-name s)
                          autocad
                          (ac:mirror3d (shape-impl s) p (+x p 1) (+y p 1)))
             (delete-shape s)))))
       shape)))
(define (mirror shape [p u0] [n uz] [copy? #t])
  (if copy?
      (union (copy-shape shape)
             (mirror shape p n #f))
      (let ((p (xyz-from-normal p n)))
        (map-failed-operation
         (lambda (s)
           (case-shape-backend
            s mirror
            (rhino
             (rh:mirror-object (shape-ref s) p (+x p 1) #f)
             s)
            (autocad
             (begin0
                 (new-shape (shape-name s)
                            autocad
                            (ac:mirror3d (shape-impl s) p (+x p 1) (+y p 1)))
               (delete-shape s)))))
         shape))))

(provide scale)
(define (scale shape s [p u0])
  (map-failed-operation
   (lambda (sh)
     (case-shape-backend
      sh scale
      (autocad
       (ac:scale-entity (shape-ref sh) p s)
       sh)
      (rhino
       ;;HACK must change the active construction plane to the perspective?????
       (rh:scale-object (shape-ref sh) p (xyz s s s) #f)
       sh)
      (opengl
       (gl:move
        (gl:scale 
         (gl:move (shape-ref sh) (*c p -1)) 
         s s s)
        p)
       sh)))
   shape))

(provide rotate)
(define (rotate shape a [p0 u0] [p1 (+z p0 1)])
  (map-failed-operation
   (lambda (s)
     (case-shape-backend
      s rotate
      (autocad
       (ac:rotate3d (shape-ref s) p0 p1 a)
       s)
      (rhino
       (rh:rotate-object (shape-ref s) p0 (radians->degrees (coterminal a)) p1 #f)
       s)))
   shape))


(def-new-shape-op (offset shape distance)
  (autocad
   (begin0
     (let-shapes ((r shape))
       (if (ac:3d-polyline? r)
           (let ((2d-r (ac:2dpoly<-3dpoly (shape-impl shape))))
             (begin0
               (singleton-value (ac:offset 2d-r distance))
               (ac:delete 2d-r)))
           (singleton-value (ac:offset r distance))))
     (delete-shape shape))))


(def-new-shape-op (revolve shape [p0 u0] [p1 (+z p0 1)] [a0 0] [a 2pi])
  (rhino
   (begin0
       (rh:revolve (shape-impl shape) p0 p1 a0 (+ a0 a))
     (delete-shape shape)))
  (autocad
   (begin0
       (ac:revolve-command (shape-impl shape) p0 p1 a0 (+ a0 a) (surface-region? shape))
     (delete-shape shape))))

(def-new-shape-op (thicken shape [h 1])
  (rhino
   (begin0
       (let-shapes ((r shape))
         (rh:thicken r (- h)))
     #;(delete-shape shape)))
  (autocad
   (begin0
       (let-shapes ((r shape))
         (if (ac:region? r)
             (let ((s (ac:conv-to-surface r)))
               (begin0
                   (ac:thicken-command s h)
                 (ac:delete s)))
             (ac:thicken-command r h)))
     (delete-shape shape))))

#|

(define (thicken distance node)
  (assert-types 'thicken (list number? node?) (list distance node))
  (new thicken-node% (distance distance) (node node)))


; lang


; align

(define (make-list-fn val1)
  (λ (val2)
    (thunk (list val1 val2))))

(define cen (make-list-fn 'cen))
(define x-cen (make-list-fn 'x))
(define x-pos (make-list-fn '+x))
(define x-neg (make-list-fn '-x))
(define y-cen (make-list-fn 'y))
(define y-pos (make-list-fn '+y))
(define y-neg (make-list-fn '-y))
(define z-cen (make-list-fn 'z))
(define z-pos (make-list-fn '+z))
(define z-neg (make-list-fn '-z))

(define (make-key-align-type sym)
  (match sym
    ('cen (center-key-align-type))
    ('+x (x-pos-key-align-type))
    ('-x (x-neg-key-align-type))
    ('+y (y-pos-key-align-type))
    ('-y (y-neg-key-align-type))
    ('+z (z-pos-key-align-type))
    ('-z (z-neg-key-align-type))))

(define (make-shape-align-type sym)
  (match sym
    ('x (x-cen-shape-align-type))
    ('+x (x-pos-shape-align-type))
    ('-x (x-neg-shape-align-type))
    ('y (y-cen-shape-align-type))
    ('+y (y-pos-shape-align-type))
    ('-y (y-neg-shape-align-type))
    ('z (z-cen-shape-align-type))
    ('+z (z-pos-shape-align-type))
    ('-z (z-neg-shape-align-type))))

(define (align-key-impl key-fn shape-fns)
  (assert-types 'align-key-impl (list procedure? (listof procedure?)) (list key-fn shape-fns))
  (let ((key-align-type (make-key-align-type (first (key-fn)))))
    (let ((key-align-types (map (const key-align-type) shape-fns))
          (key-shape (second (key-fn)))
          (shape-align-types (map (λ. make-shape-align-type first call) shape-fns))
          (node (sequence (map (λ. second call) shape-fns))))
      (new align-node%
           (key-align-types key-align-types)
           (key-shape key-shape)
           (shape-align-types shape-align-types)
           (node node)))))

(define align-key
  (case-lambda
    ((fns)
     (align-key-impl (first fns) (rest fns)))
    ((fn1 fn2 . fns)
     (align-key (list* fn1 fn2 fns)))))

(define (align-key-list key-fn . shape-fns)
  (align-key-impl key-fn shape-fns))

(define align-simple
  (case-lambda
    ((key-fn shape-fn shapes)
     (align-key-impl (key-fn (first shapes)) (map shape-fn (rest shapes))))
    ((key-fn shape-fn shape1 shape2 . shapes)
     (align-simple key-fn shape-fn (list* shape1 shape2 shapes)))))

; /align


; function-curve

(define (function-curve-impl functional-par)
  (new parametric-node% (functional-par functional-par)))

(define function-curve
  (case-lambda
    ((fn) (function-curve fn 0 1))
    ((fn t0 t1) (function-curve-impl (functional-curve fn t0 t1)))))

; /function-curve


(define (lift proc node)
  (assert-types 'lift (list procedure? node?) (list proc node))
  (new lift-node% (proc proc) (node node)))


; on

(define (make-on-type sym)
  (match sym
    ('+x (x-pos-on-type))
    ('right (x-pos-on-type))
    ('-x (x-neg-on-type))
    ('left (x-neg-on-type))
    ('+y (y-pos-on-type))
    ('back (y-pos-on-type))
    ('-y (y-neg-on-type))
    ('front (y-pos-on-type))
    ('+z (z-pos-on-type))
    ('top (z-pos-on-type))
    ('-z (z-neg-on-type))
    ('bottom (z-neg-on-type))))

(define (on-impl type node)
  (assert-types 'on-impl (list on-type? node?) (list type node))
  (new on-node% (type type) (node node)))

(define-sequence-constructor* (on type) (on-impl (make-on-type type)))

(define on-right (cλ on 'right))
(define on-left (cλ on 'left))
(define on-back (cλ on 'back))
(define on-front (cλ on 'front))
(define on-top (cλ on 'top))
(define on-bottom (cλ on 'bottom))

; /on


; sequence

(define (sequence-impl nodes)
  ;(assert-types 'sequence-impl (list (listof node?)) (list nodes))
  (let ((node (new sequence-node% (nodes nodes))))
    (set-field! srcloc
                node
                (map-append (lambda (node)
                              (get-field srcloc node))
                            nodes))
    node))

(define sequence
  (case-lambda
    ((nodes)
     (sequence-impl nodes))
    ((node . nodes)
     (sequence (cons node nodes)))))

; /sequence


; cad

; view

(define realistic (realistic-view-style))
(define wireframe (wireframe-view-style))

(define ortho (ortho-projection-type))

(define perspective
  (case-lambda
    (() (perspective 50))
    ((lens) (perspective-projection-type lens))))

(define (view-impl type projection-type style node)
  (assert-types
   'view-impl
   (list view-type? projection-type? view-style? node?)
   (list type projection-type style node))
  (new view-node% (type type) (projection-type projection-type) (style style) (node node)))

(define (auto-view direction projection-type style node/nodes)
  (view-impl (auto-view-type direction) projection-type style (node-or-sequence node/nodes)))

(define (manual-view center target projection-type style node/nodes)
  (view-impl (manual-view-type center target) projection-type style (node-or-sequence node/nodes)))

(define view
  (case-lambda
    ((direction projection-type node/nodes)
     (auto-view projection-type wireframe (node-or-sequence node/nodes)))
    ((center target projection-type node/nodes)
     (manual-view center target projection-type wireframe (node-or-sequence node/nodes)))))

(define view-ortho-top
  (case-lambda
    ((node/nodes)
     (auto-view (z -1) ortho wireframe (node-or-sequence node/nodes)))
    ((center/style node/nodes)
     (if (is-coord center/style)
         (manual-view center/style u0 ortho (node-or-sequence node/nodes))
         (auto-view (z -1) ortho 50 center/style (node-or-sequence node/nodes))))
    ((center style node/nodes)
     (manual-view center u0 ortho style (node-or-sequence node/nodes)))))

(define view-perspective
  (case-lambda
    ((node/nodes) (auto-view (xyz 1 1 -1) (perspective) realistic (node-or-sequence node/nodes)))))


; rhino

(define (add-edge-srf id)
  (begin0
    (match id
      ((list-id ids)
       (make-string-id (com:add-edge-srf (flat-strs<-ids ids)))))
    (delete-objects id)))

(define (add-hatch id)
  (begin0
    (match id
      ((string-id str)
       (make-string-id (com:add-hatch str))))
    (delete-object id)))

(define (add-interp-curve coords . args)
  (make-string-id (apply com:add-interp-curve coords args)))

(define (add-planar-srf id)
  (begin0
    (match id
      ((string-id str)
       (make-rhino-id (com:add-planar-srf (list str))))
      ((list-id ids)
       (make-rhino-id (com:add-planar-srf (flat-strs<-ids ids)))))
    (delete-object id)))

|#
;;Use something like singleton-or-union

(provide section)
(define (section s p)
  (case-shape-backend
   s section
   (rhino
    (let ((curves (rh:add-srf-section-crvs (shape-impl s) p)))
      (if (null? curves)
          (empty-shape)
          (begin0
            (failed-union
             (foldl append 
                    (list)
                    (map (lambda (c) (map rh:shape<-ref (rh:add-planar-srfs c)))
                         curves)))
            (rh:delete-objects curves)
            #;(delete-shape s)))))))

(provide copy-shapes)
(define (copy-shapes ss)
  (map-failed-operation
   (lambda (s)
     (if (or (empty-shape? s) (universal-shape? s))
         s
         (case-shape-backend 
          s copy-shapes
          (delayed
           s)
          (rhino 
           (new-shape
            (shape-name s)
            rhino
            (rh:copy-object (shape-ref s))))
          (autocad
           (new-shape
            (shape-name s)
            autocad
            (ac:copy (shape-ref s)))))))
   ss))

(provide copy-shape)
(define copy-shape copy-shapes)

#|

(define (curve-boolean-difference id1 id2)
  (match (cons id1 id2)
    ((cons (string-id str1) (string-id str2))
     (begin0
       (make-rhino-id
        (com:curve-boolean-difference str1 str2))
       (delete-object id1)
       (delete-object id2)))))

(define (curve-boolean-intersection id1 id2)
  (match (cons id1 id2)
    ((cons (string-id str1) (string-id str2))
     (begin0
       (make-rhino-id
        (com:curve-boolean-intersection str1 str2))
       (delete-object id1)
       (delete-object id2)))))

(define (curve-end-point id)
  (match id
    ((string-id str)
     (com:curve-end-point str))))

(define (curve-normal id)
  (match id
    ((string-id str)
     (com:curve-normal str))))

(define (curve-start-point id)
  (match id
    ((string-id str)
     (com:curve-start-point str))))

|#

(provide delete-shapes)
(define (delete-shapes ss)
  (let ((shapes (collect-all-shapes ss)))
    (if (null? shapes)
        #t
        (begin
          (for-each (lambda (s)
                      (set-shape-deleted?! s #t))
                    shapes)
          (case-shape-backend 
           shapes delete-shapes
           (rhino
            (rh:delete-objects (map shape-ref shapes)))
           (autocad
            (for ((s (in-list shapes)))
              (ac:delete (shape-ref s))))
           (opengl
            (for ((s (in-list shapes)))
              (gl:erase-actor (shape-ref s)))))))))

(provide delete-shape)
(define delete-shape delete-shapes)

(def-new-shape-op (surface-boundary shape)
  (rhino
   (let-shapes ((r shape))
     (begin0
         ;;HACK to be completed for the case of multiple
         ;;borders. Probably, return a failed union of curves
         (rh:singleton-id (rh:duplicate-surface-border r))
       (delete-shape shape))))
  (autocad
   (let-shapes ((r shape))
     (let ((rs (ac:explode r)))
       (cond ((null? rs)
              (error 'surface-boundary "Can't compute boundary of ~A" shape))
             ((null? (cdr rs))
              (car rs))
             ((andmap ac:line? rs)
              (let ((poly (ac:add-3d-poly (ac:closed-lines-points rs))))
                (ac:closed poly #t)
                (for ((s (in-list rs))) (ac:delete s))
                poly))
             (else
              (delete-shape shape)
              (singleton-value rs)))))))


(def-shape-op (shape-layer shape [new-layer #f])
  (autocad
   (if new-layer
       (begin
         (ac:add-layer new-layer)
         (ac:layer (shape-impl shape) new-layer)
         shape)
       (ac:layer (shape-impl shape))))
  (rhino
   (if new-layer
       (begin
         (rh:object-layer (shape-impl shape) new-layer)
         shape)
       (rh:object-layer (shape-impl shape)))))

;; (def-shape-op (shapes-layer shapes [new-layer #f])
;;   (autocad
;;    (if new-layer
;;        (begin
;;          (ac:add-layer new-layer)
;;          (for ((shape (in-list shapes)))
;;            (ac:layer (shape-impl shape) new-layer)))
;;        (remove-duplicates (map (lambda (s) (ac:layer (shape-impl s))) shapes)))))

(def-current-backend-op (current-layer [new-layer #f])
  (autocad
   (if new-layer
       (with-handlers ((exn?
                        (λ (e) 
                          (error 'current-layer "Layer ~A does not exist" new-layer))))
         (ac:clayer new-layer))
       (ac:clayer)))
  (rhino
   (if new-layer
       (rh:current-layer)
       (rh:current-layer new-layer))))

(provide with-current-layer)
(define-syntax (with-current-layer stx)
  (syntax-case stx ()
    ((_ new-layer body ...)
     (syntax/loc stx
       (let ((old-layer (current-layer)))
         (dynamic-wind
           (lambda () (current-layer new-layer))
           (lambda () body ...)
           (lambda () (current-layer old-layer))))))))

#|

(define (intersect-breps id1 id2 . args)
  (with-handlers ((com:com-exn? (λ (e) (defer-intersect id1 id2))))
    (match (cons id1 id2)
      ((cons (empty-id) _)
       (delete-object id2)
       id1)
      ((cons _ (empty-id))
       (delete-object id1)
       id2)
      ((cons (universal-id) _)
       id2)
      ((cons _ (universal-id))
       id1)
      ((cons (string-id str1) (string-id str2))
       (begin0
         (make-rhino-id (apply com:intersect-breps str1 str2 args))
         (delete-object id1)
         (delete-object id2))))))

|#

(def-new-shape-op* (join-curves shapes)
  (rhino
   (begin0
       (rh:join-curves (map shape-impl shapes) #f)
     (delete-shapes shapes)))
  (autocad
   (begin0
       (ac:join-command (map shape-impl shapes))
     (delete-shapes shapes)))
  (opengl
   (begin0
       (gl:join-curves (map shape-impl shapes))
     (delete-shapes shapes))))

(provide select-shapes)
(def-shape-op (select-shapes s)
  (rhino
   (rh:select-objects (collect-all-shapes s))))

(provide select-shape)
(define select-shape select-shapes)

#|

(define (selected-objects)
  (map make-string-id (com:selected-objects)))

(define (surface-curvature id uv)
  (match id
    ((string-id str)
     (com:surface-curvature str uv))))

(define (surface-domain id direction)
  (match id
    ((string-id str)
     (com:surface-domain id direction))))

(define (split-brep id cutter)
  (begin0
    (match (cons id cutter)
      ((cons (string-id str) (string-id cutter-str))
       (map make-string-id (com:split-brep str cutter-str #t))))
    (delete-object cutter)))

; lines


(define (nurbs-curve controls knots)
  (define (uniform-knots? knots) #t) ;;AML: must be finished
  (if (uniform-knots? knots)
      (add-curve controls (min 3 (- (length controls) 1)))
      (error "Rhino curve does not support non uniform knots")))


; surface

(define (generate-knot-vector order total)
  (let ((knots (make-vector (+ total order))))
    (let iter ((i 0))
      (if (< i order)
          (begin
            (vector-set! knots i 0.0)
            (iter (+ i 1)))
          (let iter ((j 1) (i i))
            (if (<= j (- total order))
                (begin
                  (vector-set! knots i (/ j (+ (- total order) 1.0)))
                  (iter (+ j 1) (+ i 1)))
                (let iter ((j 0) (i i))
                  (if (< j order)
                      (begin 
                        (vector-set! knots i 1.0)
                        (iter (+ j 1) (+ i 1)))
                      knots))))))))

(define (nurbs-surface controls u-knots v-knots)
  (define (degree-from-n-controls n)
    (cond ((< n 3)
           1)
          ((< n 6)
           3)
          (else
           5)))
  (let ((n-rows (length controls))
        (n-cols (length (car controls))))
    (let ((u-degree (degree-from-n-controls n-rows))
          (v-degree (degree-from-n-controls n-cols)))
      (make-string-id
       (com:add-nurbs-surface 
        (list n-rows n-cols)
        controls
        (generate-knot-vector (- u-degree 1) n-rows)
        (generate-knot-vector (- v-degree 1) n-cols)
        (list u-degree v-degree)
        #;(map (lambda (row) (map (lambda (col) 1.0) row)) controls))))))

(define (surface-from-list lst)
  (cond
    ((andmap is-coord lst)
     (make-string-id (com:add-srf-pt lst)))
    ((andmap is-curve? lst)
     (add-edge-srf (make-list-id lst)))
    (else
     (error 'surface "Unhandled shape"))))

|#

(def-new-shape-op* (surface shapes)
  (rhino
   (if (singleton? shapes)
       (let-shapes ((r (car shapes)))
         (if (rh:is-point r)
             r
             (begin0
                 (rh:singleton-id (rh:add-planar-srf r))
               (delete-shapes shapes))))
       (begin0
           (rh:add-edge-srf (map shape-impl shapes))
         (delete-shapes shapes))))
  (autocad
   (if (singleton? shapes)
       (let-shapes ((r (car shapes)))
         (if (ac:point? r)
             r
             (begin0
                 (car (ac:add-region r))
               (delete-shapes shapes))))
       (begin0
           (ac:singleton-or-union
            (ac:add-region (map shape-impl shapes)))
         (delete-shapes shapes))))
  (opengl ;;HACK Unfinished (e.g. point, but this should be handled on the abstract level)
   (if (singleton? shapes)
       (let ((shape (car shapes)))
         (begin0
             (gl:add-surface-from-curve (shape-impl shape))
           (delete-shapes shapes)))
       (begin0
           (gl:add-surface-from-curves (map shape-impl shapes))
         (delete-shapes shapes)))))

(def-new-shape (surface-grid css [closed-u? #f] [closed-v? #f])
  (rhino
   ;;Rhino requires at least 3 points in each dimension
   (if (and (null? (cddr css))
            (null? (cddr (car css))))
       (rh:add-srf-pt (append (car css) (cadr css)))
       (let ((css
              (cond ((null? (cddr css))
                     (list (car css)
                           (map (lambda (p0 p1) (/c (+c p0 p1) 2)) (car css) (cadr css))
                           (cadr css)))
                    ((null? (cddr (car css)))
                     (map (lambda (cs)
                            (/c (+c (car cs) (cadr cs)) 2))
                          css))
                    (else
                     css))))
         (rh:add-srf-pt-grid
          (vector (length css) (length (car css)))
          (foldr append (list) css)
          (vector closed-u? closed-v?)))))
  (autocad
   ;;(loft-curves (map (if closed-v? closed-spline spline) css) #f #f closed-u?)
   (let ((nu (length css))
         (nv (length (car css))))
     (cond ((> nu 256)
            (append
             (shape-ref
              (surface-grid (take css 256) #f closed-v?))
             (shape-ref
              (surface-grid (drop css 255) #f closed-v?))))
           ((> nv 256)
            (append
             (shape-ref
              (surface-grid (map (lambda (cs) (take cs 256)) css) closed-u? #f))
             (shape-ref
              (surface-grid (map (lambda (cs) (drop cs 255)) css) closed-u? #f))))
           (else
            (let ((r (ac:add-3d-mesh nu nv (foldr append (list) css))))
              (when closed-u?
                (ac:m-close r #t))
              (when closed-v?
                (ac:n-close r #t))
              (ac:type r ac:ac-bezier-surface-mesh)
              (list r))))))
  (opengl
   (gl:add-grid-surface
    (map (lambda (pts)
           (map as-world pts))
         css)
    closed-u? #t
    closed-v? #t)))

#|

; transformations

; sweep

|#

(define (surface-region? s)
  (or (surface? s) 
      (surface-circle? s)
      (surface-arc? s)
      (surface-rectangle? s)
      (surface-polygon? s)
      ;;ask the backend
      (case-shape-backend 
       s surface-region?
       (autocad
        (ac:region? (shape-impl s)))
       (rhino
        (or (rh:is-surface (shape-impl s))
            (rh:is-polysurface (shape-impl s)))))))

(define (smooth-curve? s)
  (or (spline? s) (closed-spline? s) (circle? s))) ;;HACK ellipse?

(define (closed-curve? s)
  (or (closed-line? s) (closed-spline? s)))

(def-new-shape-op (sweep path profile [rotation 0] [scale 1])
  (rhino
   (unless (= scale 1) (error "Rhino doesn't handle scale in sweep"))
   (unless (= rotation 0) (error "Rhino doesn't handle rotation in sweep"))
   (begin0
       (rh:sweep (shape-impl path) (shape-impl profile))
     (delete-shapes (list profile path))))
  (autocad
   (begin0
       (ac:sweep-command (shape-impl profile) #t (shape-impl path) (surface-region? profile) rotation scale)
     (delete-shapes (list profile path))))
  (opengl
   (unless (= scale 1) (error "OpenGL doesn't handle scale in sweep"))
   (unless (= rotation 0) (error "OpenGL doesn't handle rotation in sweep"))
   (begin0
       (gl:add-sweep (shape-impl profile) 
                     (shape-impl path) 
                     #f #;(smooth-curve? path)
                     #f #;(surface-region? profile))
     (delete-shapes (list profile path)))))

#|

; loft
|#

(def-new-shape-op* (loft-ruled shapes)
  (else
   (loft shapes #t)))

(def-new-shape-op ((guided-loft* guided-loft) shapes rails [ruled? #f] [solid? #f] [closed? #f])
  (rhino
   (if (> (length rails) 2)
       (error 'guided-loft "Rhino only supports two rails but were passed ~A" rails)
       (let ((r (rh:add-sweep2 (map shape-impl rails) (map shape-impl shapes))))
         (when solid?
           (rh:cap-planar-holes r))
         (delete-shapes shapes)
         (delete-shapes rails)
         r)))
  (autocad
   (begin0
       (ac:loft-command (ac:loft-objects-guides-string (map shape-impl shapes) (map shape-impl rails) solid?)
                        (if ruled? ac:loftnormals-ruled ac:loftnormals-smooth-fit)
                        closed?)
     (delete-shapes shapes)
     (delete-shapes rails))))

(define (curve? s)
  (or (line? s)
      (closed-line? s)
      (spline? s)
      (closed-spline? s)
      (circle? s)
      (arc? s)))

(provide guided-loft)
(define (guided-loft shapes rails [ruled? #f] [solid? #f] [closed? #f])
  (cond ((null? (cdr shapes))
         (delete-shapes rails)
         (car shapes))
        ((andmap curve? shapes)
         (guided-loft* shapes rails ruled? solid? closed?))
        ((andmap surface-region? shapes)
         (guided-loft* shapes rails ruled? #t closed?))
        (else
         (error 'loft-shapes "cross sections are not either curves or surfaces"))))

(provide loft)
(define (loft shapes [ruled? #f] [solid? #f] [closed? #f])
  (cond ((null? (cdr shapes))
         (car shapes))
        ((andmap point? shapes)
         (begin0
           ((if ruled?
                (if closed? polygon line)
                (if closed? closed-spline spline))
            (map point-position shapes))
           (delete-shapes shapes)))
        ((andmap curve? shapes)
         (loft-curves shapes ruled? solid? closed?))
        ((andmap surface-region? shapes)
         (loft-surfaces shapes ruled? #t closed?))
        ((and (null? (cddr shapes))
              (ormap point? shapes))
         (let-values ([(p s)
                       (if (point? (car shapes))
                           (values (car shapes) (cadr shapes))
                           (values (cadr shapes) (car shapes)))])
           (cond ((curve? s)
                  (loft-curve-point s p solid?))
                 ((surface-region? s)
                  (loft-surface-point s p #t))
                 (else
                  (error 'loft-shapes "can't loft the shapes ~A" shapes)))))
        (else
         (error 'loft-shapes "cross sections are not either curves or surfaces"))))

(def-new-shape-op (loft-curves shapes [ruled? #f] [solid? #f] [closed? #f])
  (rhino
   (let ((rs (map shape-impl shapes)))
     ;;Adjust seams
     #;(let ((ref-p (rh:evaluate-curve (car rs) 0.0)))
       (for ((r (in-list (cdr rs))))
         (rh:curve-seam r (rh:curve-closest-point r ref-p))))
     (let ((ref-p (xyz -100000 -10000 -10000)))
       (for ((r (in-list rs)))
         (rh:curve-seam r (rh:curve-closest-point r ref-p))))
     (let ((r (rh:add-loft-srf rs rh:com-omit rh:com-omit
                               (if ruled? rh:loft-type-straight rh:loft-type-normal)
                               rh:com-omit rh:com-omit closed?)))
       (when solid?
         (rh:cap-planar-holes r))
       (delete-shapes shapes)
       r)))
  (autocad
   (begin0
       (ac:loft-command (ac:loft-objects-string (map shape-impl shapes) solid?)
                        (if ruled? ac:loftnormals-ruled ac:loftnormals-smooth-fit)
                        closed?)
     (delete-shapes shapes)))
  (opengl
   (begin0
     (gl:add-loft (map shape-impl shapes) ruled? solid? closed? (andmap line? shapes))
     (delete-shapes shapes))))

(def-new-shape-op (loft-curve-point shape point [solid? #f])
  (rhino
   (let-shapes ((r shape)
                (p point))
     (let ((r (rh:extrude-curve-point r (rh:point-coordinates p))))
       (when solid?
         (rh:cap-planar-holes r))
       (delete-shape shape)
       (delete-shape point))))
  (autocad
   (let-shapes ((r shape)
                (p point))
     (begin0
         (ac:loft-command (ac:loft-to-point-string
                           (shape-ref (surface-boundary shape))
                           (car (ac:coordinates p))
                           solid?)
                          ac:loftnormals-ruled
                          #f)
       (delete-shape shape)
       (delete-shape point))))
  (opengl
   (let-shapes ((s shape)
                (p point))
     (begin0
         (gl:add-loft-curve-point s p solid? (line? shape))
       (delete-shape shape)
       (delete-shape point)))))

(def-new-shape-op (loft-surfaces shapes [ruled? #f] [solid? #t] [closed? #f])
  (else
    (begin0
        (loft-curves (map surface-boundary shapes) ruled? solid? closed?)
      (delete-shapes shapes))))

(def-new-shape-op (loft-surface-point shape point [solid? #t])
  (else
   (begin0
     (loft-curve-point (surface-boundary shape) point solid?)
     (delete-shape shape))))

(provide slice)
(define (slice shape [p u0] [n uz])
  (cond ((empty-shape? shape)
         shape)
        ((failed-union? shape)
         (union
          (map (lambda (s) (slice s p n))
               (failed-operation-shapes shape))))
        ((failed-subtraction? shape)
         (subtraction
          (map (lambda (s) (slice s p n))
               (failed-operation-shapes shape))))
        (else
         (line p (+c p n))
         (slice* shape (xyz-from-normal p n)))))

(def-new-shape-op ((slice* slice) shape plane)
  (autocad
   (begin0
       (ac:slice-command (shape-ref shape) plane uz)
     (set-shape-deleted?! shape #t)))
  (rhino
   (begin0
       (let ((p plane)
             (r (shape-ref shape)))
         (let ((pw (as-world p)))
           (let ((n (-c (as-world (+z p 1)) pw)))
             (let ((cutter (rh:add-cut-plane
                            r pw
                            (as-world (+x p 1))
                            (-c (as-world (+y p 1)) pw))))
               (let ((rs (rh:split-brep r cutter #f)))
                 (begin0
                     (if (null? rs)
                         r
                         (begin
                           (rh:delete-object r)
                           (let-values (([keep clear]
                                         (partition rh:cap-planar-holes rs)))
                             (rh:delete-objects clear)
                             (let-values (([keep clear]
                                           (partition
                                            (lambda (r)
                                              (let ((c (car (rh:surface-volume-centroid r))))
                                                (< (dot-c (-c c pw) n) 0)))
                                            keep)))
                               (rh:delete-objects clear)
                               ;;HACK Check this
                               (singleton-value keep)))))
                   (rh:delete-objects cutter)))))))
     (set-shape-deleted?! shape #t))))


(def-new-shape (grid-surface ptss [closed-s? #f] [closed-t? #f] [smooth-s? #t] [smooth-t? #t])
  (opengl
   (gl:add-grid-surface
    (map (lambda (pts)
           (map as-world pts))
         ptss)
    closed-s? smooth-s?
    closed-t? smooth-t?)))

#|
; /loft



(define (rotate angle normal id/ids)
  (let ((rotate-fn (if (list? id/ids) rotate-objects rotate-object)))
    (rotate-fn id/ids u0 (radians->degrees angle) normal #f)))

(define (scale type size id/ids)
  (match type
    ((center-scaling-type)
     (error 'scale "Rhino scale: center not implemented"))
    ((origin-scaling-type)
     (let ((scale-fn (if (list? id/ids) scale-objects scale-object)))
       (scale-fn id/ids u0 size #f)))))

(define (section type plane id)
  (match type
    ((auto-section-type)
     (error 'add-srf-section-crvs "Rhino section: implemented only for lines"))
    ((line-section-type)
     (add-srf-section-crvs id plane))
    ((surface-section-type)
     (error 'add-srf-section-crvs "section is only implemented for lines"))))
|#


;;half spaces

(def-new-shape (half-space p n)
  (else
   (cons p n)))

(def-shape-op (half-space-point hs)
  (else
   (car (shape-ref hs))))

(def-shape-op (half-space-normal hs)
  (else
   (cdr (shape-ref hs))))

;;HACK to be continued, to implement
;;slices (or cuts)
;;

;;Helpers
(define (fully-contained? s0 s1)
  (cond ((failed-union? s1)
         (ormap (lambda (s) (fully-contained? s0 s))
                (failed-operation-shapes s1)))
        ((failed-subtraction? s1)
         (let ((ss (failed-operation-shapes s1)))
           (and (fully-contained? s0 (car ss))
                (not (ormap (lambda (s) (fully-contained? s0 s))
                            ss)))))
        (else
         (rh:fully-contained? 
          (rh:singleton-id (shape-ref s0))
          (rh:singleton-id (shape-ref s1))))))

(define (rh:fully-contained? r0 r1)
  ;;if all points of the bounding box of r0 are contained in r1
  ;;then it's guaranteed that r0 is fully contained in r1.
  (andmap (lambda (p) (rh:is-point-in-surface r1 p))
          (list<-bbox (rh:bounding-box r0))))

(define (fully-not-contained? s0 s1)
  (cond ((failed-union? s1)
         (andmap (lambda (s) (fully-not-contained? s0 s))
                 (failed-operation-shapes s1)))
        ((failed-subtraction? s1)
         (let ((ss (failed-operation-shapes s1)))
           (or (fully-not-contained? s0 (car ss))
               (ormap (lambda (s) (fully-contained? s0 s))
                      ss))))
        (else
         (rh:fully-not-contained?
          (rh:singleton-id (shape-ref s0))
          (rh:singleton-id (shape-ref s1))))))

(define (rh:fully-not-contained? r0 r1)
  ;;if neither the centroid nor all points of the bounding box of r0
  ;;are not contained in r1 then it's guaranteed that r0 is fully not
  ;;contained in r1.
  (error "Don't use this (yet)")
  (not (ormap (lambda (p) (rh:is-point-in-surface r1 p))
              (list<-bbox (rh:bounding-box r0)))))

;;Note: a totally contained shape is also a 
;;partially contained shape
(define (rh:partially-contained? r0 r1)
  (let ((c0 (rh:point-in-surface r0)))
    (rh:is-point-in-surface r1 c0))
  ;; (let ((c0 (car (rh:surface-volume-centroid r0))))
  ;;   (if (rh:is-point-in-surface r0 c0)
  ;;       (rh:is-point-in-surface r1 c0)
  ;;       (error "Can't compute containement")))
  )

(define (partially-contained? s0 s1)
  (cond ((failed-union? s1)
         (ormap (lambda (s) (partially-contained? s0 s))
                (failed-operation-shapes s1)))
        ((failed-subtraction? s1)
         (partially-contained? s0 (car (failed-operation-shapes s1))))
        (else
         (rh:partially-contained?
          (rh:singleton-id (shape-ref s0))
          (rh:singleton-id (shape-ref s1))))))


(provide union)
(define (union . shapes-tree)
  (let ((ss (filter-not empty-shape? (remove-duplicates (flatten shapes-tree)))))
    (cond ((null? ss)
           (empty-shape))
          ((null? (cdr ss))
           (car ss))
          ((ormap universal-shape? ss)
           (delete-shapes ss)
           (universal-shape))
          (else
           (let-values ([(failed ss) (partition failed-operation? ss)])
             (let-values ([(failed-unions failed-subtractions) (partition failed-union? failed)])
               (failed-union (append (append-map failed-operation-shapes failed-unions) ss failed-subtractions))
               ;; (let ((s (pure-union (append (append-map failed-operation-shapes failed-unions) ss))))
               ;;   (cond ((null? failed-subtractions)
               ;;          s)
               ;;         ((universal-shape? s) ;;This never happens (I suppose)
               ;;          (delete-shapes failed)
               ;;          s)
               ;;         ((empty-shape? s)
               ;;          (failed-union failed-subtractions))
               ;;         (else
               ;;          (distribute-operation
               ;;           union
               ;;           s
               ;;           failed-subtractions))))
               ))))))

(def-shape-op (pure-union2 sh0 sh1)
  (rhino
   (let-shapes ((r0 sh0) (r1 sh1))
     (let ((r (rhino-boolean-union (flatten (list r0 r1)))))
       (cond (r
              (set-shape-deleted?! sh0 #t)
              (set-shape-deleted?! sh1 #t)
              (new-shape 'union rhino r))
             ;;union in Rhino only tests surface union
             ;;This means that although the surface union might
             ;;fail, the solid union might exist if one surface
             ;;fully contains the other.
             ((fully-contained? sh0 sh1)
              ;(rh:delete-object r0)  just to make sure we're tracking deletions correctly           
              (delete-shape sh0)
              sh1)
             ((fully-contained? sh1 sh0)
              ;(rh:delete-object r1)
              (delete-shape sh1)
              sh0)
             (else
              #f)))))
  (autocad
   (let-shapes ((r0 sh0) (r1 sh1))
     (new-shape 'union autocad (ac:boolean-union r0 r1)))))

(define (rhino-boolean-union ids)
  (rh:boolean-union2 ids #t))
  ;; (displayln "RHINO->")
  ;; (displayln ids)
  ;; (let ((r (debug "RH:UNION " (rh:boolean-union2 ids #f))))
  ;;   (when r
  ;;     (display "Deleting!")
  ;;     (displayln ids)
  ;;     (read)
  ;;     (rh:delete-objects ids)
  ;;     (display "Selecting")
  ;;     (rh:select-objects r)
  ;;     (read))
  ;;   r))

(define (pure-union ss)
  (cond ((null? ss)
         (empty-shape))
        ((null? (cdr ss))
         (car ss))
        (else
         (case-shape-backend
          (car ss) union
          (rhino
           ;;First, try a faster single union
           ;;NO, don't do this because the union of 3 shapes where only two can be united
           ;;causes the union to succeed although there's one shape missing.
           ;;Second, more precise and slow computation
           (let loop ((curr (car ss)) (rest (cdr ss)) (failed (list)) (success? #f))
             (if (null? rest)
                 (if (null? failed)
                     curr
                     (let ((ss (reverse (cons curr failed))))
                       (if success?
                           (loop (car ss) (cdr ss) (list) #f)
                           (failed-union ss))))
                 (let ((r (pure-union2 curr (car rest))))
                   (if r
                       (loop r (cdr rest) failed #t)
                       (loop curr (cdr rest) (cons (car rest) failed) success?))))))
          (autocad
           ;;We don't have multi-argument union in autocad, but unions do not fail
           (let loop ((curr (car ss)) (rest (cdr ss)))
             (if (null? rest)
                 curr
                 (let ((r (pure-union2 curr (car rest))))
                   (loop r (cdr rest))))))))))

(provide intersection)
(define (intersection . shapes-tree)
  (let ((ss (filter-not universal-shape? (remove-duplicates (flatten shapes-tree)))))
    (cond ((null? ss)
           (universal-shape))
          ((null? (cdr ss))
           (car ss))
          ((ormap empty-shape? ss)
           (delete-shapes ss)
           (empty-shape))
          (else
           (let-values ([(failed ss) (partition failed-operation? ss)])
             (let ((s (pure-intersection ss)))
               (cond ((null? failed)
                      s)
                     ((empty-shape? s)
                      (delete-shapes failed)
                      s)
                     (else
                      (distribute-operation
                       intersection
                       (car failed)
                       (if (universal-shape? s)
                           (cdr failed)
                           (cons s (cdr failed))))))))))))

(define (copy-shapes-n ss n)
  (if (= n 1)
      (list ss)
      (cons (copy-shapes ss)
            (copy-shapes-n ss (- n 1)))))

(define (distribute-operation oper s ss)
  (cond ((failed-union? s)
         (let ((failed-shapes (failed-operation-shapes s)))
           (union
            (map (lambda (u ss)
                   (oper (cons u ss)))
                 failed-shapes
                 (copy-shapes-n ss (length failed-shapes))))))
        ((failed-subtraction? s)
         (let ((failed-shapes (failed-operation-shapes s)))
           (subtraction
            (map (lambda (u ss)
                   (oper (cons u ss)))
                 failed-shapes
                 (copy-shapes-n ss (length failed-shapes))))))
        ((failed-subtraction? (car ss))
         (let ((failed-shapes (failed-operation-shapes (car ss))))
           (oper (map subtraction
                      (copy-shapes-n s (length failed-shapes))
                      failed-shapes)
                 (cdr ss))))
        (else
         (error "To be treated"))))


(define (pure-intersection ss)
  (if (null? ss)
      (universal-shape)
      (if (null? (cdr ss))
          (car ss)
          (let loop ((curr (car ss)) (rest (cdr ss)))
            (cond ((null? rest)
                   curr)
                  ((empty-shape? curr)
                   (delete-shapes rest)
                   curr)
                  ;; ((half-space? (car rest))
                  ;;  (loop (slice curr (car rest))
                  ;;        (cdr rest)))
                  (else
                   (loop (pure-intersection2 curr (car rest))
                         (cdr rest))))))))

(def-shape-op (pure-intersection2 sh0 sh1)
  (delayed
   (failed-intersection (list sh0 sh1)))
  (rhino
   (let-shapes ((r0 sh0) (r1 sh1))
     (let ((r (rh:boolean-intersection2 r0 r1 #t)))
       (if r
           (begin
             (set-shape-deleted?! sh0 #t)
             (set-shape-deleted?! sh1 #t)
             (if (rh:singleton-id? r)
                 (new-shape 'intersection rhino (rh:singleton-id r))
                 (failed-union (map (lambda (r) (new-shape 'intersection rhino r)) r))))
           ;;Intersection in Rhino only tests surface intersection
           ;;This means that although the surface intersection might
           ;;fail, the solid intersection might exist if one surface
           ;;contains the other.
           (cond ((partially-contained? sh0 sh1)
                  (delete-shape sh1)
                  sh0)
                 ((partially-contained? sh1 sh0)
                  (delete-shape sh0)
                  sh1)
                 (else
                  (delete-shapes (list sh0 sh1))
                  (empty-shape)))))))
  (autocad
   (let-shapes ((r0 sh0) (r1 sh1))
     (new-shape 'intersection autocad (ac:boolean-intersection r0 r1))))
  (opengl
   (displayln "WARNING: intersection is not operational in OpenGL")
   (empty-shape)))


(provide subtraction)
(define (subtraction . shapes-tree)
  (let ((ss (flatten shapes-tree)))
    (if (null? ss)
        (empty-shape) ;(error "No shapes to subtract")
        (let ((s (car ss))
              (ss (cdr ss)))
          (cond ((null? ss)
                 s)
                ((empty-shape? s)
                 s)
                ((ormap (lambda (o)
                          (or (universal-shape? o)
                              (eq? s o))) ;;Perhaps we should use a equal-shape? test
                        ss)
                 (delete-shapes (cons s ss))
                 (empty-shape))
                ((failed-union? s)
                 (let ((failed (failed-operation-shapes s)))
                   (union (map (lambda (u s)
                                 (subtraction (cons u s)))
                               failed
                               (copy-shapes-n ss (length failed))))))
                ((failed-subtraction? s)
                 (let ((ss1 (failed-operation-shapes s)))
                   (subtraction (car ss1)
                                (union (cdr ss1) ss))))
                (else
                 (let-values ([(failed ss) (partition failed-operation? ss)])
                   (let-values ([(failed-unions failed-subtractions) (partition failed-union? failed)])
                     (let ((s (pure-subtraction
                               (cons s (append (append-map failed-operation-shapes failed-unions) ss)))))
                       (cond ((null? failed-subtractions)
                              s)
                             ((empty-shape? s)
                              (delete-shapes failed-subtractions)
                              s)
                             (else
                              (distribute-operation
                               subtraction
                               s
                               (cdr failed)))))))))))))

#;(define (debug tag . val)
  (display tag) (displayln val) 
  (car val))

(define (pure-subtraction ss)
  (if (null? ss)
      (empty-shape)
      (if (null? (cdr ss))
          (car ss)
          (case-shape-backend
           (car ss) subtraction
           (delayed
            (failed-subtraction ss))
           (rhino
            ;;First, for just two shapes
            (if (null? (cddr ss))
                (pure-subtraction2 (car ss) (cadr ss))
                ;;Second, try a faster single subtraction
                ;;No, don't do this for the same reasons that it shouldn't be
                ;;done for unions
                (let ((r #f #;(rh:boolean-difference2 (shape-ref (car ss))
                                                 (flatten (map shape-ref (cdr ss)))
                                                 #t)))
                  (if r
                      (begin
                         (for-each (lambda (s) (set-shape-deleted?! s #t)) ss)
                         (if (rh:singleton-id? r)
                           (new-shape 'subtraction rhino (rh:singleton-id r))
                           (failed-union (map (lambda (r) (new-shape 'subtraction rhino r)) r))))
                      ;;Second, more precise and slow computation
                      (let loop ((curr (car ss)) (rest (cdr ss)) (failed (list)) (success? #f))
                        (if (null? rest)
                            (if (null? failed)
                                curr
                                (let ((ss (reverse failed)))
                                  (if success?
                                      (loop curr ss (list) #f)
                                      (failed-subtraction ss))))
                            (let ((r (subtraction curr (car rest))))
                              (cond ((empty-shape? r)
                                     (delete-shapes (cdr rest))
                                     (delete-shapes failed)
                                     (empty-shape))
                                    ((failed-subtraction? r)
                                     (loop curr (cdr rest) (cons (car rest) failed) success?))
                                    (else
                                     (loop r (cdr rest) failed #t))))))))))
           (autocad
            ;;First, for just two shapes
            (if (null? (cddr ss))
                (pure-subtraction2 (car ss) (cadr ss))
                (let loop ((curr (car ss)) (rest (cdr ss)))
                  (if (null? rest)
                      curr
                      (let ((r (pure-subtraction2 curr (car rest))))
                        (cond ((empty-shape? r)
                               (delete-shapes (cdr rest))
                               (empty-shape))
                              (else
                               (loop r (cdr rest)))))))))
           (opengl
            (displayln "WARNING: subtraction is not operational in OpenGL")
            (empty-shape))))))

(def-shape-op (pure-subtraction2 sh0 sh1)
  (rhino
   (let-shapes ((r0 sh0) (r1 sh1))
     (let ((r (rh:boolean-difference2 r0 r1 #t)))
       (if r
           (begin
             (set-shape-deleted?! sh0 #t)
             (set-shape-deleted?! sh1 #t)
             (if (rh:singleton-id? r)
                 (new-shape 'subtraction rhino (rh:singleton-id r))
                 (failed-union (map (lambda (r) (new-shape 'subtraction rhino r)) r))))
           ;;subtraction in Rhino only tests surface subtraction
           ;;This means that although the surface subtraction might
           ;;fail, the solid subtraction might exist if one surface
           ;;contains the other.
           (cond #;((fully-not-contained? sh1 sh0)
                  (delete-shape sh1)
                  sh0)
                 ((fully-contained? sh0 sh1)
                  (delete-shape sh0)
                  sh1)
                 ((fully-contained? sh1 sh0)
                  (failed-subtraction (list sh1 sh0)))
                 ((or (partially-contained? sh0 sh1)
                      (partially-contained? sh1 sh0))
                  (if (> (car (rh:surface-volume (rh:singleton-id (shape-ref sh0))))
                         (car (rh:surface-volume (rh:singleton-id (shape-ref sh1)))))
                      (failed-subtraction (list sh0 sh1))
                      (begin
                        (delete-shapes (list sh0 sh1))
                        (empty-shape))))
                 (else
                  (delete-shape sh1)
                  sh0))))))
  (autocad
   (let-shapes ((r0 sh0) (r1 sh1))
     (set-shape-deleted?! sh0 #t)
     (set-shape-deleted?! sh1 #t)
     (new-shape 'subtraction autocad (ac:boolean-subtraction r0 r1)))))

(def-shape-op (resolve shape)
  (rhino
   (cond ((failed-union? shape)
          (let ((ss (map shape-impl (failed-operation-shapes shape))))
            (rh:singleton-id (rh:boolean-union ss))))
         ((failed-subtraction? shape)
          (let ((ss (map shape-impl (failed-operation-shapes shape))))
            (rh:singleton-id
             (rh:boolean-difference (list (car ss)) (cdr ss)))))
         (else
          (shape-ref shape))))
  (autocad
   (cond ((failed-union? shape)
          (let ((shapes (failed-operation-shapes shape)))
            (if (andmap curve? shapes)
                (ac:join-curves (map shape-ref shapes))
                (let ((ss (map shape-impl (failed-operation-shapes shape))))
                  (foldl ac:boolean-union (car ss) (cdr ss))))))
         (else
          (shape-ref shape)))))

#|

(define (thicken distance id)
  (match id
    ((string-id str)
     (make-string-id
      (rscript:offset-surface-solid-command str distance)))))


; lang

; par

(define (par-circle shape)
  (let ((center (circle-center-point shape))
        (normal (curve-normal shape))
        (radius (circle-radius shape)))
    (let ((translation
           (apply m-translation (list-of-coord center)))
          (rotation
           (m-rotation (angle-c uz normal (cross-c uz normal)) (cross-c uz normal))))
      (par:make-transformation-parametric
       (par:make-transformation-parametric
        (par:make-circle-curve radius)
        rotation)
       translation))))

(define (par shape)
  (finally
   (cond ((is-circle? shape)
          (par-circle shape))
         (else
          (error 'par "Unhandled par type")))
   (λ () (delete-object shape))))

; /par


; cad

(define (delete-shapes)
  (delete-objects (all-objects))
  (com:clear-command-history)
  #;(rscript:clear-all-meshes-command))

(define (render-shapes width height path type)
  (match type
    ((draft-render-type)
     (com:create-preview-image path com:view-perspective (list width height)))))


; view

(define (set-view-projection! projection-type)
  (match projection-type
    ((ortho-projection-type)
     (com:view-projection com:view-perspective com:view-projection-mode-parallel))
    ((perspective-projection-type lens)
     (com:view-projection com:view-perspective com:view-projection-mode-perspective)
     (com:view-camera-lens com:view-perspective lens))))

(define (set-view-style! style)
  (let ((display-mode
         (match style
           ((wireframe-view-style) com:view-display-mode-wireframe)
           ((realistic-view-style) com:view-display-mode-render-preview))))
    (com:view-display-mode com:view-perspective display-mode)))

(define (auto-view direction projection-type style shape/shapes)
  (set-view-projection! projection-type)
  (com:view-camera-target com:view-perspective (*c direction -1) u0)
  (set-view-style! style)
  (let ((selected-objects (selected-objects)))
    (com:unselect-all-objects)
    (select shape/shapes)
    (com:zoom-selected com:view-perspective)
    (com:unselect-all-objects)
    (select selected-objects)))

(define (manual-view center target projection-type style)
  (set-view-projection! projection-type)
  (com:view-camera-target com:view-perspective center target)
  (set-view-style! style))

(define (view type projection-type style shape/shapes)
  (begin0
    shape/shapes
    (match type
      ((auto-view-type direction)
       (auto-view direction projection-type style shape/shapes))
      ((manual-view-type center target)
       (manual-view center target projection-type style)))))
;; circle

|#
(def-shape-op (transform shape matrix)
  (rhino
   (rh:transform-object (shape-impl shape) matrix)))


#|

Compatibility operations

|#

(def-current-backend-op (view-parameters)
  (autocad
   (ac:view-parameters)))


(def-current-backend-op (set-view camera target lens)
  (rhino
   (unless (rh:is-view-maximized "Perspective")
     (rh:maximize-restore-view "Perspective"))
   (rh:view-projection "Perspective" 2) ;;perspective
   (rh:view-camera-lens "Perspective" lens)
   (rh:view-camera-target "Perspective" camera target)
   (rh:view-display-mode "Perspective" 2)) ;;render
  (autocad
   (ac:view-conceptual)
   (ac:perspective 1)
   (ac:dview-zoom-command camera target lens (distance camera target))
   (ac:skystatus 2))
  (opengl
   (gl:set-view camera target lens)))

(def-current-backend-op (2d-top)
  (rhino
   (unless (rh:is-view-maximized "Top")
     (rh:maximize-restore-view "Top"))
   (rh:view-projection "Top" 1) ;;parallel
   (rh:view-display-mode "Top" 0)) ;;wireframe
  (autocad
   (ac:view-wireframe)
   (ac:view-top))
  (opengl
   (gl:set-view-top))
  (tikz
   ;;Top is the default in TikZ
   #t))

(def-current-backend-op (zoom-extents)
  (rhino
   (rh:zoom-extents rh:com-omit #t))
  (autocad
   (ac:zoom-extents))
  (opengl
   (gl:zoom-extents))
  (tikz
   ;;TikZ zooms automatically
   #t))

(def-current-backend-op (refresh)
  (opengl
   (gl:refresh)))

;;Render

(define render-dir (make-parameter #f))
(define render-ext (make-parameter "png"))
(define render-height (make-parameter 300))
(define render-width (make-parameter 300))
(define render-floor-width (make-parameter 1000))
(define render-floor-height (make-parameter 1000))

(provide set-render-dir!)
(define (set-render-dir! val)
  (render-dir (path->directory-path (build-path val))))

(provide set-render-size!)
(define (set-render-size! width heigth)
  (render-width width)
  (render-height heigth))


(define floor-layer (make-parameter "Floor"))
(define shapes-layer (make-parameter "DarkGray"))

(provide white-renders)
(define (white-renders)
  (shapes-layer "DarkGray")
  (floor-layer "Floor")
  (set-render-dir! "F:\\Users\\aml\\Dropbox\\Renders\\autorenders")
  (current-layer (shapes-layer)))

(provide black-renders)
(define (black-renders)
  (shapes-layer "DarkGray")
  (floor-layer "FloorBlack")
  (set-render-dir! "F:\\Users\\aml\\Dropbox\\Renders\\autorendersBlack\\")
  (current-layer (shapes-layer)))

(define floor-distance (make-parameter 0))

(define floor-extra-width (make-parameter 2000))

(define floor-extra-factor (make-parameter 20))

(define last-make-floor-for-bounding-box #f)

(provide make-floor-for-bounding-box)
(define (make-floor-for-bounding-box bb)
  (set!	last-make-floor-for-bounding-box bb)
  (let ((p0 (car bb))
	(p1 (cdr bb)))
    (let ((w (max (* (floor-extra-factor)
                     (distance p0 p1))
                  (floor-extra-width))))
      (shape-layer
       (box
        (xyz (- (min (xyz-x p0) (xyz-x p1)) w)
             (- (min (xyz-y p0) (xyz-y p1)) w)
             (- (xyz-z p0) 1 (floor-distance)))
        (xyz (+ (max (xyz-x p0) (xyz-x p1)) w)
             (+ (max (xyz-y p0) (xyz-y p1)) w)
             (- (xyz-z p0) 0 (floor-distance))))
       (floor-layer)))))

(provide make-floor)
(define (make-floor)
  (make-floor-for-bounding-box (all-objects-bounding-box)))

;;Bounding box
(define (object-bounding-box s)
  (let ((bb (bounding-box s)))
    (cons (xyz (bbox-min-x bb) (bbox-min-y bb) (bbox-min-z bb))
          (xyz (bbox-max-x bb) (bbox-max-y bb) (bbox-max-z bb)))))

(define (combine-bb bb0 bb1)
  (cons (xyz (min (xyz-x (car bb0)) (xyz-x (car bb1)))
	     (min (xyz-y (car bb0)) (xyz-y (car bb1)))
	     (min (xyz-z (car bb0)) (xyz-z (car bb1))))
	(xyz (max (xyz-x (cdr bb0)) (xyz-x (cdr bb1)))
	     (max (xyz-y (cdr bb0)) (xyz-y (cdr bb1)))
	     (max (xyz-z (cdr bb0)) (xyz-z (cdr bb1))))))

(define (objects-bounding-box objs)
  (let ((bb (object-bounding-box (car objs))))
    (for ((obj (cdr objs)))
      (set! bb (combine-bb bb (object-bounding-box obj))))
    bb))

(define (points-bounding-box pts)
  (let ((bb (cons (car pts) (car pts))))
    (for ((pt (cdr pts)))
      (set! bb (combine-bb bb (cons pt pt))))
    bb))

(define (all-objects-bounding-box)
  (objects-bounding-box
    (all-shapes)))

(set-render-dir! "F:\\Users\\aml\\Dropbox\\Renders\\autorenders")
(set-render-size! 1920 1080)

(def-current-backend-op (render-view name)
  (autocad
   (let ((path (format "~A~A.~A" (path->string (render-dir)) name (render-ext))))
     (when (file-exists? path)
       (delete-file path))
     (ac:skystatus ac:sky-status-background-and-illumination)
     ;; (shapes-layer (all-shapes) (shapes-layer))
     ;; (shape-layer (make-floor) (floor-layer))
     (ac:render-command "P" (render-width) (render-height) path))))

(def-current-backend-op (render-stereo-view name)
  (autocad
   #t
   ;; (match (get-view)
   ;;   ((list camera target lens)
   ;;    (let ((direction (-c target camera))
   ;;          (l (distance camera target)))
   ;;      (let ((d (/ (if (< l 1) (/ l 10.0) 0.1) 2.0)))
   ;;        (let ((d+ (pol d (+ (pol-phi direction) pi/2)))
   ;;              (d- (pol d (- (pol-phi direction) pi/2))))
   ;;          (set-view (+c camera d+) (if (< l 1) target (+c target d+)) lens)
   ;;          (render-view (strcat filename "L"))
   ;;          (set-view (+c camera d-) (if (< l 1) target (+c target d-)) lens)
   ;;          (render-view (strcat filename "R")))))))
   ))

#|
Utilities: think about moving them to a different file
|#

(provide random-range random set-ultimo-aleatorio-gerado!)

(define (random-range x0 x1)
  (+ x0 (random (- x1 x0))))

(define ultimo-aleatorio-gerado 12345)

(define (set-ultimo-aleatorio-gerado! v)
  (set! ultimo-aleatorio-gerado v))

(define (aleatorio)
  (set! ultimo-aleatorio-gerado
        (proximo-aleatorio ultimo-aleatorio-gerado))
  ultimo-aleatorio-gerado)

(define (proximo-aleatorio ultimo-aleatorio)
  (let ((teste (- (* 16807 (remainder ultimo-aleatorio 127773))
                  (* 2836  (quotient ultimo-aleatorio 127773)))))
    (if (> teste 0)
        (if (> teste 2147483647)
            (- teste 2147483647)
            teste)
        (+ teste 2147483647))))

(define (random x)
  (if (inexact? x)
      (* x (/ (aleatorio) 2147483647.0))
      (remainder (aleatorio) x)))

(def-current-backend-op (prompt-point [str "Select position"])
  (autocad
   (ac:get-point u0 str))
  (rhino
   (rh:get-point str)))

(def-current-backend-op (prompt-integer [str "Integer?"])
  (autocad
   (ac:get-integer str))
  (rhino
   (rh:get-integer str)))

(def-current-backend-op (prompt-real [str "Real?"])
  (autocad
   (ac:get-real str))
  (rhino
   (rh:get-real str)))

(def-current-backend-op (prompt-shape [str "Select shape"])
  (autocad
   (ac:shape<-ref
    (ac:get-entity str)))
  (rhino
   (rh:shape<-ref
    (rh:get-object str))))

(define (ac:shape<-ref r)
  (new-shape (ac:object-geometry r) autocad r))

;;TODO: Update this to follow the approach taken for autocad
(define (rh:shape<-ref r)
  (new-shape
   (cond ((rh:is-point r) 'point)
         ((rh:is-circle r) 'circle)
         ((rh:is-curve r) 
          (if (rh:is-curve-closed r) 'closed-spline 'spline))
         ((or (rh:is-line r)
              (rh:is-polyline r))
          (if (rh:is-curve-closed r) 'closed-line 'line))
         ((and (rh:is-object r) (rh:is-object-solid r)) 'solid)
         ((rh:is-surface r) 'surface)
         ((rh:is-polysurface r) 'surface)
         (else
          (error 'rh:shape<-ref "Unknown Rhino object ~A" r)))
    rhino r))

;;HACK: To be finished
(define (gl:shape<-ref r)
  (new-shape
   (cond ;((gl:is-point r) 'point)
         ;((rh:is-circle r) 'circle)
         ;((rh:is-curve r) 'spline)
         ;((rh:is-line r) 'line)
         ;((rh:is-polyline r) 'line)
         ;((and (rh:is-object r) (rh:is-object-solid r)) 'solid)
         ;((rh:is-surface r) 'surface)
         ;((rh:is-polysurface r) 'surface)
         (else
          'solid #;
          (error 'gl:shape<-ref "Unknown OpenGL object ~A" r)))
    opengl r))


(def-current-backend-op (insert-objects-from filename [predicate #f])
  (autocad
   (let ((doc (ac:open-dbx-doc filename)))
     (let ((objs (ac:all-objects (ac:modelspace doc))))
       (let ((filtered-objs (if predicate (filter predicate objs) objs)))
         (ac:copy-objects doc filtered-objs))))))


(def-current-backend-op (save-screen-png filename)
  (autocad
   (ac:save-screen-png filename)))

(def-current-backend-op (save-screen-eps filename)
  (autocad
   (ac:save-screen-eps filename)))

;(require racket/trace)
;(trace union mirror copy-shape copy-shapes map-failed-operation resolve shape-ref shape-impl)
;; (trace slice slice* mirror move rotate scale map-failed-operation)
;(trace shape-impl failed-operation? union pure-union pure-union2 failed-union intersection subtraction pure-subtraction pure-subtraction2 distribute-operation fully-contained? fully-not-contained? partially-contained? delete-shape delete-shapes surface? point?)
;(trace loft-curve-point)
;(trace surface loft loft-curves)


(def-current-backend-op (pause)
  (autocad
   (read-char))
  (rhino
   (read-char))
  (opengl
   (read-char)))

(def-new-shape (contour s p spacing)
  (rhino
   (rh:add-srf-contour-crvs (shape-impl s) p spacing)))

(provide erase-2d-top)
(define (erase-2d-top) 
  (delete-all-shapes)
  (2d-top))

(provide zoom-2d-top)
(define (zoom-2d-top)
  (2d-top)
  (zoom-extents))

(provide zoom-3d-conceptual)
(define (zoom-3d-conceptual)
  "to be implemented"
  )