(define-module (language python module python)
  #:use-module (oop goops)
  #:use-module (ice-9 match)
  #:use-module (ice-9 readline)
  #:use-module ((oop pf-objects) #:select
                (<p> <property> class-method static-method refq
                     py-super-mac))
  #:use-module (language python exceptions       )
  #:use-module (language python def              )
  #:use-module (language python for              )
  #:use-module (language python try              )
  #:use-module (language python yield            )
  #:use-module (language python list             )
  #:use-module (language python dict             )
  #:use-module (language python set              )
  #:use-module (language python compile          )
  #:use-module (language python string           )
  #:use-module (language python set              )
  #:use-module (language python number           )
  #:use-module (language python dir              )
  #:use-module (language python hash             )
  #:use-module (language python property         )
  #:use-module (language python range            )
  #:use-module (language python tuple            )

  #:replace (list abs min max hash)
  #:re-export (Exception StopIteration send sendException next
                         GeneratorExit sendClose RuntimeError
                         len dir next dict None property range
			 tuple)
  #:export (print repr complex float int round
                  set all any bin callable
                  chr classmethod staticmethod
                  divmod enumerate filter format
                  getattr hasattr hex isinstance
                  iter map sum id input oct ord pow super))

(define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))

(define print
  (case-lambda
    (()  (format #t "~%"))
    ((x) (format #t "~s~%" x))
    (l   (format #t "~s~%" l))))

(define (repr x) (format #f "~a" x))
(define abs     py-abs)
(define string  pystring)
(define complex py-complex)
(define float   py-float)
(define int     py-int)
(define round   py-round)
(define set     py-set)
(define all     py-all)
(define any     py-any)
(define bin     py-bin)
(define divmod  py-divmod)
(define format  py-format)
(define hash    py-hash)
(define hex     py-hex)

(define-method (callable  x                     ) #f)
(define-method (callable (x <procedure>        )) #t)
(define-method (callable (x <procedure-class>  )) #t)
(define-method (callable (x <applicable>       )) #t)
(define-method (callable (x <primitive-generic>)) #t)
(define-method (callable (x <p>))
  (refq x '__call__))
                            
(define chr integer->char)
  
(define classmethod  class-method)
(define staticmethod static-method)

(define (enumerate l)
  (make-generator enumerate
    (lambda (yield)
      (for ((x : l)) ((i 0))
           (yield i x)
           (+ i 1)))))

(define (filter f l)
  (make-generator enumerate
    (lambda (yield)
      (for ((x : l)) ()
           (if (f x)
               (yield x))))))

(define miss ((@ (guile) list) 'miss))

(define* (getattr a b #:optional (k miss))
  (let ((r (refq a (symbol->string b) k)))
    (if (eq? r miss)
        (raise AttributeError "object/class ~a is missing attribute ~a" a b)
        r)))

(define (hasattr a b)
  (let ((r (refq a (symbol->string b) miss)))
    (not (eq? r miss))))
  
(define (isinstance o cl)
  (if (pair? cl)
      (or
       (isinstance o (car cl))
       (isinstance o (cdr cl)))
      (is-a? o cl)))

(define iter
  (case-lambda
    ((o) (aif it (wrap-in o)
              it
              (aif get (refq o '__getitem__)
                   (make-generator iter
                                   (lambda (yield)
                                     (for () ((i 0))
                                          (yield (get i))
                                          (+ i 1))))
                   (raise TypeError "not iterable" o))))
    ((f sent)
     (make-generator iter
                     (lambda (yield)
                       (for () ()
                            (let ((r (f)))
                              (if (equal? r sent)
                                  (break)
                                  (yield r)))))))))
                               
                                      

(define-syntax map
  (lambda (x)
    (syntax-case x ()
      ((map f a ...)
       (with-syntax (((x ...) (generate-temporaries #'(a ...))))
         #'(make-generator map
             (lambda (yield)
               (for ((x : a) ...) () (yield (f x ...))))))))))
                    
(define* (sum i #:optional (start 0))
  (for ((x : i)) ((s start))
       (+ s x)
       #:final
       s))


(define (id x) (object-address x))

(define (input str)
  (format #t str)
  (readline))

(define (idx x) x)

(def (py-min (* l) (= key idx) (= default miss))
     (let lp ((l l))
       (match l
         ((it)
          (for ((x : it)) ((s default) (b default))
               (if (eq? s miss)
                   (values (key x) x)
                   (let ((k (key x)))
                     (if (< k s)
                         (values k x)
                         (values s b))))
               #:final
               (if (eq? b miss)
                   (raise ValueError "min does not work for zero length list")
                   b)))
         (_ (lp ((@ (guile) list) l))))))

(def (py-max (* l) (= key idx) (= default miss))
     (let lp ((l l))
       (match l
         ((it)
          (for ((x : it)) ((s default) (b default))
               (if (eq? default miss)
                   (values (key x) x)
                   (let ((k (key x)))
                     (if (> k s)
                         (values k x)
                         (values s b))))
               #:final
               (if (eq? b miss)
                   (raise ValueError "min does not work for zero length list")
                   b)))
         (_ (lp ((@ (guile) list) l))))))

(define (oct x) (+ "0o" (number->string (py-index x) 8)))
(define (ord x) (char->integer (string-ref (pylist-ref x 0) 0)))

(define pow
  (case-lambda
    ((x y)
     (expt x y))
    ((x y z)
     (py-mod (expt x y) z))))

(define-syntax-rule (super . l) (py-super-mac . l))       

(define min  py-min)
(define max  py-max)
(define list pylist)