(define-module (language python module collections abc)
  #:use-module (oop pf-objects)
  #:export (Container Hashable Iterable Iterator Reversable Generator
		      Sized Callable Collection Sequence MutableSequence
		      ByteString Set MutableSet Mapping MutableMapping
		      MappingView ItemsView KeysView ValuesView))

(define-python-class Container ()
  (define __containes__
    (lambda x (error "not implemented"))))

(define-python.class Hashable ()
  (define __hash__
    (lambda x (error "not implemented"))))

(define-python-class Iterable ()
  (define __iter__
    (lambda x (error "not implemented"))))

(define-python-class Iterator (Iterable)
  ;; Mixin
  (define __iter__
    (lambda (self) self))

  ;; Abstract
  (define __next__
    (lambda x (error "not implemented"))))

(define-python-class Reversable (Iterable)
  (define __reversed__
    (lambda x (error "not implemented"))))

(define-python-class Generator (Iterator)
  ;; Mixin
  (define __next__
    (lambda (self) ((ref self 'send))))

  (define close
    (lambda (self)
      ((ref self 'throw) GeneratorExit)))
  
  ;; Abstract
  (define send
    (lambda x (error "not implemented")))
  (define throw
    (lambda x (error "not implemented"))))

(define-python-class Sized ()
  (define __len__
    (lambda x (error "not implemented"))))

(define-python-class Callable ()
  (define __call__
    (lambda x (error "not implemented"))))

(define-python-class Collection (Sized Iterable Container))

(define-python-class Sequence (Reversable Collection)
  ;; Mixin
  (define __contains__
    (lambda (self x)
      (let ((f (ref self '__getitem)))
	(for ((i : (range (len self))))
	     (if (equal? x (f i))
		 (break #t))
	     #:final #f))))

  (define __iter__
    (lambda (self)
      ((mk-iterator       
	(lambda (yield)
	  (let ((f (ref self '__getitem)))
	    (for ((i : (range (len self))))
		 (yield (f i)))))))))

  (define __reversed__
    (lambda (self)
      ((mk-iterator
	(lambda (yield)
	  (let ((f (ref self '__getitem)))
	    (for ((i : (range (len self) 0 -1)))
		 (yield (f i)))))))))

  (define index
    (lambda (self x)
      (let ((f (ref self '__getitem__)))
	(for ((i : (range (len self))))
	     (if (equal? x (f i))
		 (break y))
	     (raise IndexError)))))

  (define count
    (lambda (self x)
      (let ((f (ref self '__getitem__)))
	(for ((i : (range (len self)))) ((n 0))
	     (if (equal? x (f i))
		 (+ n 1)
		 n)
	     #:final n))))
      
			   
  ;; Abstract
  (define __getitem__
    (lambda x (error "not implemented"))))

(define-python-class MutableSequence (Sequence)
  ;; Mixin
  (define append
    (lambda (self x)
      ((ref self 'insert) (len self) x)))

  (define extend
    (lambda (self it)
      (let ((f (ref self 'insert)))
	(for ((x : it)) ((i (len self)))
	  (f i x)
	  (+ i 1)))
      (values)))

  (define pop
    (lambda (self)
      (let* ((i (- (len self) 1))
	     (x ((ref self '__getitem__) i)))
	((ref self '__delitem__) i)
	x)))

  (define remove
    (lambda (self x)
      (let ((f (ref self '__getitem__)))
	(for ((i : (range (len self))))
	     (if (equal? x (f i))
		 (begin
		   ((ref self '__delitem__) i)
		   (break)))))
      (values)))

	     
  (define __iadd__
    (lambda (self seq)
      (let ((f (ref self 'insert)))
	(for ((x : seq)) ((i (len self)))
	     (f i x)
	     (+ i 1)))
      (values)))
	   
  
  ;; Abstract
  (define __setitem__
    (lambda x (error "not implemented")))
  (define __delitem__
    (lambda x (error "not implemented")))
  (define insert
    (lambda x (error "not implemented"))))

(define-python-class ByteString (Sequence))

(define-python-class Set (Collection)
  ;; Mixins
  (define __le__
    (lambda (self o)
      (let ((f (ref o '__contains__)))
	(for ((x : ((ref self '__iter__))))
	     (if (not (f x))
		 (break #f))))))
  
  (define __lt__
    (lambda (self o)
      (if (equal? (len self) (len o))
	  #f
	  (let ((f (ref o '__contains__)))
	    (for ((x : ((ref self '__iter__))))
		 (if (not (f x))
		     (break #f)))))))

  (define __eq__
    (lambda (self o)
      (if (not (equal? (len self) (len o)))
	  #f
	  (let ((f (ref o '__contains__)))
	    (for ((x : ((ref self '__iter__))))
		 (if (not (f x))
		     (break #f)))))))

  (define __ne__
    (lambda (self o) (not ((ref self '__eq__) o))))
  
  (define __gt__
    (lambda (self o)
      (if (equal? (len self) (len o))
	  #f
	  (let ((f (ref self '__contains__)))
	    (for ((x : ((ref o '__iter__))))
		 (if (not (f x))
		     (break #f)))))))
    
  (define __ge__
    (lambda (self o)
      (let ((f (ref self '__contains__)))
	(for ((x : ((ref o '__iter__))))
	     (if (not (f x))
		 (break #f))))))

  (define __and__
    (lambda (self o)
      (let ((f (ref o '__contains__))
	    (s (set))
	    (a (ref s 'add)))
	(for ((x : ((ref self '__iter__)))) ()
	     (if (f x)
		 (a x)))
	s)))
  
  (define __or__
    (lambda (self o)
      (let ((s (set))
	    (a (ref s 'add)))
	(for ((x : ((ref self '__iter__)))) ()
	     (a x))
	(for ((x : ((ref o '__iter__)))) ()
	     (a x))
	s)))
      
  (define __sub__
    (lambda (self o)
      (let ((f (ref o '__contains__))
	    (s (set))
	    (a (ref s 'add)))
	(for ((x : ((ref self '__iter__)))) ()
	     (if (not (f x))
		 (a x)))
	s)))

  (define __xor__
    (lambda (self o)
      (let ((fo (ref o    '__contains__))
	    (fs (ref self '__contains__))
	    (s (set))
	    (a (ref s 'add)))
	(for ((x : ((ref self '__iter__)))) ()
	     (if (not (fo x))
		 (a x)))
	(for ((x : ((ref o '__iter__)))) ()
	     (if (not (fs x))
		 (a x)))
	s)))

  (define disjoint
    (lambda (self o)
      (let ((f (ref o '__contains__))
	    (s (set))
	    (a (ref s 'add)))
	(for ((x : ((ref self '__iter__)))) ()
	     (if (f x)
		 (break #f))
	     #:final #t)))))
 
(define-python-class MutableSet (Set)
  ;; Abstract methods
  (define add
    (lambda x (error "not implemented")))
  (define discard
    (lambda x (error "not implemented")))

  ;; Mixins
  (define clear)
  (define pop)
  (define remove)
  (define __ior__)
  (define __iand__)
  (define __ixor__)
  (define __isub__))

(define-python-class Mapping (Collection)
  ;; Mixins
  (define __contains__)
  (define keys)
  (define items)
  (define values)
  (define get)
  (define __eq__)
  (define __ne__))

(define-python-class MutableMapping (Mapping)
  ;; Abstracts
  (define __setitem__)
  (define __delitem__)

  ;; Mixins
  (define pop)
  (define popitem)
  (define clear)
  (define update)
  (define setdefault))

(define-python-class MappingView (Sized)
  ;; Mixins
  (define __init__
    (lambda (self m)
      (set self '_mapping m)))
  
  (define __len__
    (lambda (self) (len (ref self '_mapping)))))
		    
(define-python-class ItemsView   (MappingView Set)
  ;; Mixins
  (define __contains__
    (lambda (self x)))
  (define __iter__
    (lambda (self)
      ((ref (ref self '_mapping) 'items)))))
      
(define-python-class KeysView    (MappingView Set)
  ;; Mixins
  (define __contains__
    (lambda (self k)))
      
  (define __iter__
    (lambda (self)
      ((ref (ref self '_mapping) 'keys)))))

(define-python-class ValuesView  (MappingView)
    ;; Mixins
  (define __contains__
    (lambda (self x)))
  
  (define __iter__
    (lambda (self)
      ((ref (ref self '_mapping) 'values)))))


(name-object Container Hashable Iterable Iterator Reversable Generator
	     Sized Callable Collection Sequence MutableSequence
	     ByteString Set MutableSet Mapping MutableMapping
	     MappingView ItemsView KeysView ValuesView)