(defun contain (wyr zm)
    (let ((answ 0))
    (loop for x in wyr do
        (if (listp x)
            (setq answ (+ answ (contain x zm))))
        (if (eql x zm)
            (setq answ (+ answ 1)))
    )
    answ
    )
)

(defun pack (wyr)
    (if (listp wyr)
        wyr
        (list wyr))
)

(defun simplify (wyr)
    (if (listp (second wyr))
        (setf (nth 1 wyr) (simplify (second wyr)))
    )
    (if (and (not (null (third wyr))) (listp (third wyr)))
        (setf (nth 2 wyr) (simplify (third wyr)))
    )
    ;; (write (second wyr))
    ;; (write-line "")
    ;; (write (third wyr))
    ;; (write-line "")
    (if (and (numberp (second wyr)) (numberp (third wyr)))
        (funcall (first wyr) (second wyr) (third wyr))
        wyr
    )
)

(defun integrate_private (wyr)
    (let ((operator (first wyr)) (expresion (second wyr)) (var (third wyr)))
        ;; (write expresion)
        ;; (write-line "")
        ;; (write (type-of var))
        ;; (write-line "")
        (if (string= operator 'INTEGRAL)
            (let ((char_type (first expresion)) (f_elem (second expresion)) (s_elem (third expresion)))
                ;; (write (type-of +))
                ;; (write-line "")
                (if (numberp char_type)
                    (list '* char_type var)
                (if (eql var char_type)
                    (list '/ (list 'expt var 2) 2)
                    (case char_type
                        (+ (list '+ (integrate (list 'integral (pack f_elem) var))
                            (integrate (list 'integral (pack s_elem) var))))
                        (- (list '- (integrate (list 'integral (pack f_elem) var))
                            (integrate (list 'integral (pack s_elem) var))))
                        (*  (if (eql (contain (list f_elem) var) 0)
                                (list '* f_elem (integrate (list 'integral (pack s_elem) var)))
                            (if (eql (contain (list s_elem) var) 0)
                                (list '* s_elem (integrate (list 'integral (pack f_elem) var)))
                                (list 'INTEGRAL expresion))))
                        (/  (if (and (eql (contain (list f_elem) var) 0) (eql var s_elem))
                                (list '* f_elem  (list 'log var))
                            (if (eql (contain (list s_elem) var) 0)
                                (list '/ (integrate (list 'integral (pack f_elem) var)) s_elem)
                                (list 'INTEGRAL expresion))))
                        (expt  (if (and (eql (contain (list f_elem) var) 0) (eql s_elem var))
                                (list '/ (list 'expt f_elem s_elem) (list 'log f_elem))
                            (if (and (eql (contain (list s_elem) var) 0) (eql f_elem var))
                                (list '/ (list 'expt f_elem (list '+ s_elem 1)) (list '+ s_elem 1))
                                (list 'INTEGRAL expresion))))
                        (otherwise "nieznane")
                    )
                ))
            )
            ;; expresion
        )
    )
)

(defun integrate (wyr)
    (simplify (integrate_private wyr))
)




(write (integrate '(integral (* 2 x) x)))
(write-line "")
(write (integrate '(integral (+ 2 x) x)))
(write-line "")
(write (integrate '(integral (/ 2 x) x)))
(write-line "")
(write (integrate '(integral (/ x 2) x)))
(write-line "")
(write (integrate '(integral (expt 2 x) x)))
(write-line "")
(write (integrate '(integral (* 5 (expt x 16)) x)))
(write-line "")
(write (integrate '(integral (- 2 x) x)))
(write-line "")
(write (integrate '(integral (+ (* (- 5 (expt y 12)) x) 2) x)))
(write-line "")