;;;; Common Lisp implementation of the Web Economy Bullshit Generator.
;;;; See http://dack.com/web/bullshit.html for the original.
;;;; This edition was enhanced to also generate sentences, paragraphs or
;;;; HTML pages.
;;;;
;;;; Examples:
;;;;
;;;; CL-USER> (bullshit-list)
;;;; (TARGET MAGNETIC INFOMEDIARIES)
;;;;
;;;; CL-USER> (bullshit-item)
;;;; "Exploit sexy initiatives."
;;;;
;;;; CL-USER> (bullshit-sentence)
;;;; "We guarantee to engage enterprise relationships to reintermediate
;;;;  cross-media vortals."
;;;;
;;;; CL-USER> (bullshit-paragraph)
;;;; "It is imperative that we productize cross-media e-markets or enable
;;;;  compelling applications.  We engineer holistic methodologies in order
;;;;  to embrace 24/7 infrastructures to monetize impactful niches.  We
;;;;  guarantee to expedite sexy mindshare and redefine 24/7 e-business.
;;;;  This makes it possible to orchestrate killer technologies to e-enable
;;;;  best-of-breed bandwidth to be able to utilize compelling
;;;;  infrastructures."
;;;;
;;;; (bullshit-page) may also be used to generate bullshit HTML pages :)

(defparameter *verbs*
  '#(
     aggregate
     architect
     benchmark
     brand
     cultivate
     deliver
     deploy
     disintermediate
     drive
     e-enable
     embrace
     empower
     enable
     engage
     engineer
     enhance
     envisioneer
     evolve
     expedite
     exploit
     extend
     facilitate
     generate
     grow
     harness
     implement
     incentivize
     incubate
     innovate
     integrate
     iterate
     leverage
     matrix
     maximize
     mesh
     monetize
     morph
     optimize
     orchestrate
     productize
     recontextualize
     redefine
     reintermediate
     reinvent
     repurpose
     revolutionize
     scale
     seize
     strategize
     streamline
     syndicate
     synergize
     synthesize
     target
     transform
     transition
     unleash
     utilize
     visualize
     whiteboard)
  "Verb patterns to be returned as first symbol by BULLSHIT-LIST.")

(defparameter *adjectives*
  '#(
     24/365
     24/7
     B2B
     B2C
     back-end
     best-of-breed
     bleeding-edge
     bricks-and-clicks
     clicks-and-mortar
     collaborative
     compelling
     cross-platform
     cross-media
     customized
     cutting-edge
     distributed
     dot-com
     dynamic
     e-business
     efficient
     end-to-end
     enterprise
     extensible
     frictionless
     front-end
     global
     granular
     holistic
     impactful
     innovative
     integrated
     interactive
     intuitive
     killer
     leading-edge
     magnetic
     mission-critical
     next-generation
     one-to-one
     open-source
     out-of-the-box
     plug-and-play
     proactive
     real-time
     revolutionary
     rich
     robust
     scalable
     seamless
     sexy
     sticky
     strategic
     synergistic
     transparent
     turn-key
     ubiquitous
     user-centric
     value-added
     vertical
     viral
     virtual
     visionary
     web-enabled
     wireless
     world-class)
  "Adjective patterns to be returned as second symbol by BULLSHIT-LIST.")

(defparameter *nouns*
  '#(
     action-items
     applications
     architectures
     bandwidth
     channels
     communities
     content
     convergence
     deliverables
     e-business
     e-commerce
     e-markets
     e-services
     e-tailers
     experiences
     eyeballs
     functionalities
     infomediaries
     infrastructures
     initiatives
     interfaces
     markets
     methodologies
     metrics
     mindshare
     models
     networks
     niches
     paradigms
     partnerships
     platforms
     portals
     relationships
     ROI
     synergies
     web-readiness
     schemas
     solutions
     supply-chains
     systems
     technologies
     users
     vortals
     web-services)
  "Noun patterns to be returned as third symbol from BULLSHIT-LIST.")

(defparameter *sentence-starts*
  '#(
     we
     |we guarantee to|
     |it is important to|
     |it is imperative that we|
     |we ensure to|
     |this makes it possible to|
     |this enables us to|
     |this allows us to|
     |always remember that we|
     |moreover, we|
     |basically, we|
     |we seize the opportunity to|
     |our company aims to|
     |we aim to|
     |our expertise permits us to|
     |we work together to|
     |our experts|
     |for starters, we|
     |as leaders, we|
     |never forget that we work hard to|
     |our array of services|
     |our leading strategies|
     |our customers can be assured that we|
     |microsoft products are deprecated because our software|
     |our superior software|
     |our turn-key customized solutions|
     |our customized software|)
  "Sentence prefix patterns to be used by SENTENCE-LIST.")

(defparameter *sentence-separators*
  '#(
     and
     or
     to
     |to thus|
     |in order to|
     |to be able to|
     |which enable us to|
     |allowing us to|
     |permitting to|
     |making possible to|
     |enabling to|
     |prioritizing tasks to|
     |rendering possibilities to|
     |defining methods to|)
  "Pattern to be inserted in-between BULLSHIT-LIST generated lists in order 
to form a sentence by SENTENCE-LIST.")

(defun random-symbol (vector)
  "Returns a random symbol from specified VECTOR."
  (svref vector (random (array-dimension vector 0))))

(defun bullshit-list ()
  "Returns a list consisting of three randomly chosen symbols."
  (list (random-symbol *verbs*)
	(random-symbol *adjectives*)
	(random-symbol *nouns*)))

(defun sentence-list ()
  "Returns a list consisting of random symbols forming a sentence, 
internally using BULLSHIT-LIST."
  (let ((r (1+ (random 3))))
    (nconc
     (list (random-symbol *sentence-starts*))
     (reduce #'nconc
	     (loop repeat r
		collect (nconc (bullshit-list)
			       (list (random-symbol *sentence-separators*)))))
     (bullshit-list))))

(defun paragraph-list ()
  "Returns a list consisting of SENTENCE-LIST lists."
  (let ((r (+ 3 (random 3))))
    (loop repeat r collect (sentence-list))))

(defun list-print (list &optional (stream nil))
  (let ((str (lists-print list)))
    (format stream "~A" (subseq str 0 (- (length str) 2)))))

(defun lists-print (lists &optional (stream nil))
  "Creates a string holding properly formatted sentences for each list of
LISTS, optionally printing it if STREAM is specified.  Also works for non-
nested list."
  (let ((str (make-array '(0) :element-type 'character
			      :fill-pointer 0 :adjustable t)))
    (with-output-to-string (s str)
      (if (listp (first lists))
	  (mapcar #'(lambda (l)
		      (lists-print l s))
		  lists)
	  (format s "~@(~{~A~^ ~}~).  " lists)))
    (format stream "~A" str)))

;;; XXX Simple imperfect string wrapper function.
(defun print-wrap (string &optional (stream nil) (columns 66))
  "Wraps supplied STRING to be printable within COLUMNS, optionally printing 
the result if STREAM is supplied."
  (let ((s "")
	(col 0))
    (declare (type fixnum col))
    (loop for c across string do
	 (if (and (char= c #\Space)
		  (> col columns))
	     (setf s (concatenate 'string s (list #\Newline))
		   col 0)
	     (setf s (concatenate 'string s (list c))
		   col (1+ col))))
    (format stream "~A" s)))


;;;; General user functions

(defun bullshit-item (&optional (stream nil))
  "Prints a formatted single bullshit item."
  (print-wrap (list-print (bullshit-list)) stream))

(defun bullshit-sentence (&optional (stream nil))
  "Prints a formatted bullshit sentence."
  (print-wrap (list-print (sentence-list)) stream))

(defun bullshit-paragraph (&optional (stream nil))
  "Prints a formatted bullshit paragraph."
  (print-wrap (list-print (paragraph-list)) stream))

(defun bullshit-page (&optional (stream nil))
  "Prints a bullshit HTML page."
  (let ((s "")
	(r (+ 3 (random 3)))
	(bsi (bullshit-item)))
    (loop repeat r do
	 (setf s (concatenate 'string s
			      "<p>"
			      (bullshit-paragraph)
			      "</p>"
			      (list #\Newline))))
    (format stream
	    "<html><head><title>~A</title></head><body>
<h1>~A</h1>
~A</body></html>"
	    bsi bsi s)))