(define-module (language python module)
  #:use-module (oop pf-objects)
  #:use-module (ice-9 match)
  #:use-module (language python exceptions)
  #:use-module (language python yield)
  #:use-module (language python try)
  #:use-module (language python dir)
  #:export (Module))

(define e (list 'e))

(define _k
  (lambda (k)
    (if (string? k)
	(string->symbol k)
	k)))

(define _m
  (lambda (self)
    (if (rawref self '_private)
	(rawref self '_module)
	(rawref self '_export))))

(define-python-class Module ()
  (define __setprivate__
    (lambda (self p)
      (set self '_isprivate p)))

  (define __init__
    (case-lambda
     ((self pre l nm)
      (match l
	((name)
	 (_make self (cons name pre) (cons name nm)))
	((name . (and l (name2 . _)))
	 (set self name2 (Module (cons name pre) l (cons name nm)))
	 (_make self (cons name pre) (cons name nm)))))
     
     ((self l)     
      (if (pair? l)
	  (if (and (> (length l) 3)
		   (equal? (list (list-ref l 0)
				 (list-ref l 1)
				 (list-ref l 2))
			   '(language python module)))
	      (__init__ self (reverse '(language python module)) (cdddr l) '())
	      (_make self l l))
	  (__init__ self
		    (map string->symbol
			 (string-split l #\.)))))))
  (define _make
    (lambda (self l nm)
      (begin
	(set self '_private #f)
	(set self '__dict__ self)
	(set self '__name__ (string-join (map symbol->string (reverse nm)) "."))
	(let ((_module (resolve-module (reverse l))))
	  (set self '_export (module-public-interface _module))
	  (set self '_module _module)))))
    
  (define __getattribute__
    (lambda (self k . l)
      (define (fail)
	(if (pair? l)
	    (car l)
	    (raise KeyError "getattr in Module")))
      (if (rawref self '_module)
	  (let ((k (_k k))
		(m (_m self)))
	    (let ((x (module-ref m k e)))
	      (if (eq? e x)
		  (fail)
		  x)))
	  (fail))))

  (define __setattr__
    (lambda (self k v)
      (let ((k     (_k k))
	    (fail  (lambda () (raise KeyError "getattr in Module"))))
	(if (rawref self k)
	    (fail)
	    (if (rawref self '_module)
		(let ((m (_m self)))
		  (catch #t
			 (lambda ()
			   (if (module-defined? m k)
			       (module-set! m k v)
			       (module-define! m k v)))			
			 (lambda x (pk 'fail x))))
		(fail))))))

  (define __delattr__
    (lambda (self k)
      (define (fail) (raise KeyError "getattr in Module"))
      (if (rawref self '_module)
	  (let ((m (_m self))
		(k (_k k)))
	    (if (module-defined? m k)
		(module-remove!  m k)
		(raise KeyError "delattr of missing key in Module")))
	  (fail))))

  (define __repr__
    (lambda (self) (ref self '__name__)))

  (define __getitem__
    (lambda (self k)
      (define k (if (string? k) (string->symbol k) k))
      (__getattr__ self k)))
  
  (define __iter__
    (lambda (self)
      (define m (_m self))
      ((make-generator ()
	 (lambda (yield)
	   (define l '())
	   (define (f k v) (set! l (cons (list (symbol->string k) v) l)))
	   (module-for-each f m)
	   (let lp ((l l))
	     (if (pair? l)
		 (begin
		   (apply yield (car l))
		   (lp (cdr l)))))))))))