(define (compose f g)
  (lambda (x) (f (g x))))


(define (rotate-point pt ang)
  (make-posn (- (* (posn-x pt) (cos ang)) (* (posn-y pt) (sin ang)))
              (+ (* (posn-y pt) (cos ang)) (* (posn-x pt) (sin ang)))))

(define (make-rotation ang)
  (lambda (pt) (rotate-point pt ang)))

(define (translate-pt pt x y)
  (make-posn (+ (posn-x pt) x)
             (+ (posn-y pt) y)))

(define (scale-pt pt x y)
  (make-posn (* (posn-x pt) x)
             (* (posn-y pt) y)))

(define (make-scale x y)
  (lambda (pt) (scale-pt pt x y)))
(define (make-translate x y)
  (lambda (pt) (translate-pt pt x y)))

(define (transform-pts transform pts)
  (map transform pts))

(define square (list (make-posn -1 -1)
                     (make-posn 1 -1)
                     (make-posn 1 1)
                     (make-posn -1 1)
                     (make-posn -1 -1)))

(define (draw-poly-line pts color)
  (if  (<  (length pts) 2)
       #t
       (begin
         (draw-solid-line (car pts) (cadr pts) color)
         (draw-poly-line (cdr pts) color))))



       
(start 300 300)
;(draw-solid-line (make-posn 0 0) (make-posn 100 100) 'red)
;(draw-solid-line (make-posn 0 0) (rotate-point (make-posn 100 100) (/ pi 6)) 'red)
;(posn-x (rotate-point (make-posn 100 100) (/ pi 4)))
;(draw-poly-line (list (make-posn 0 0) (make-posn 100 100)) 'red)
(define pts1 (transform-pts
                 (compose (make-translate 50 50)
                          (compose (make-scale 10 10)
                                   (make-rotation (/ pi 4))))
                 square))
;
;(draw-poly-line (transform-pts
;                 (compose (make-translate 50 50)
;                          (compose (make-scale 10 10)
;                                   (make-rotation (/ pi 4))))
;                 square) 'red)

(define (make-translate-rotate-scale x y s)
  (lambda (ang)
    (compose (make-translate x y ) 
             (compose (make-scale s s) (make-rotation ang) ))))

(define trans1 (make-translate-rotate-scale 150 150 100))
;(draw-poly-line (transform-pts
;                 (trans1 (/ pi 4))
;                 square) 'red)

(define (draw-star n inc)
  (if (< n 0)
      #t
      (begin
        (draw-poly-line (transform-pts
                       (trans1 (* n inc))
                       square) 'red)
        (draw-star (- n 1) inc))))
(define n 50)
(draw-star n (/ pi n))