#!/usr/bin/env gosh

#|
Font Size Converter
This programm convert font size for each unit, and display standard output.

Usage: gosh font-size-conv.scm [-dpi][-Qpmx][--] [fonr-size]

Example: $ gosh font-size-conv.scm -dpi 300 -p 144
 Base Font Size (pt)	: 144	pt
 When Convert to Q	: 203.0	Q
 When Convert to mm	: 50.8	mm
 When Convert to px	: 600.0	px

Oprions:
 -dpi<rate>	Set DPI(Dot Per Inch) <rate>	(Default 96)
 -Q (Default)	Receive Argument as Q		(Q)
 -p|point	Receive Argument as Point	(pt)
 -m|mm		Receive Argument as Millimeter	(mm)
 -x|pixel	Receive Argument as Pixel	(px)
 -h|help	Display Help about this Program then Exit
|#

(use gauche.parseopt)

(define (inv r) (/. 1 r))

(define pt:Q 1.41)
(define Q:pt (inv pt:Q))

(define mm:pt 2.8345)
(define pt:mm (inv mm:pt))

(define mm:Q 4)
(define Q:mm (inv mm:Q))

(define inch:mm 25.4)
(define mm:inch (inv inch:mm))

(define inch:pt 72)
(define pt:inch (inv inch:pt))

(define inch:Q  101.6)
(define Q:inch  (inv inch:Q))

(define dpi 96)

(define pt:px (* pt:inch dpi))
(define px:pt (inv pt:px))

(define Q:px  (* Q:inch dpi))
(define px:Q  (inv Q:px))

(define mm:px (* mm:inch dpi))
(define px:mm (inv mm:px))

(define (set-dpi alt-dpi)
  (set! dpi alt-dpi)
  (set! pt:px (* pt:inch dpi))
  (set! px:pt (inv pt:px))
  (set! Q:px  (* Q:inch dpi))
  (set! px:Q  (inv Q:px))
  (set! mm:px (* mm:inch dpi))
  (set! px:mm (inv mm:px)))

(define (round-n n)
  (let1 base (expt 10 (- n 1))
    (.$  (cut /. <> base) round (pa$ * base))))

(define (-> rate value)
  ((round-n 2) (* value rate)))

(define (disp-x-convert base base-unit conv-list)
  (cons #`"Base Font Size (,|base-unit|)\t: ,|base|\t,|base-unit|"
	(map (^ (x)
	       (let ([unit (car x)]
		     [rate (cdr x)])
		 #`"When Convert to ,|unit|\t: ,(-> rate base)\t,|unit|"))
	     conv-list)))

(define (disp-pt-convert pt)
  (disp-x-convert pt 'pt `((Q . ,pt:Q) (mm . ,pt:mm) (px . ,pt:px))))

(define (disp-mm-convert mm)
  (disp-x-convert mm 'mm `((Q . ,mm:Q) (pt . ,mm:pt) (px . ,mm:px))))

(define (disp-px-convert px)
  (disp-x-convert px 'px `((Q . ,px:Q) (pt . ,px:pt) (mm . ,px:mm))))

(define (disp-Q-convert Q)
  (disp-x-convert Q 'Q `((pt . ,Q:pt) (mm . ,Q:mm) (px . ,Q:px))))

(define (usage)
  (format (current-error-port)
	  "Usage : ~a [-dpi<rate>][-Qpmx][--] [font-size]\n"
	  *program-name*)
  (opt-info)
  (exit 2))

(define (opt-info)
  (for-each
   print
   '("options:"
     " -dpi<rate>\tSet DPI(Dot Per Inch) <rate>\t(Default 96)"
     " -Q (Default)\tReceive Argument as Q\t\t(Q)"
     " -p|point\tReceive Argument as Point\t(pt)"
     " -m|mm\t\tReceive Argument as Millimeter\t(mm)"
     " -x|pixel\tReceive Argument as Pixel\t(px)"
     " -h|help\tDisplay Help about this Program then Exit")))

(define (unknown-option opt)
  (print #`"Error : Unknown Option -- ,|opt|")
  (usage))

(define (not-number arg)
  (print #`"Error : Font size required Number. but got ,|arg|")
  (usage))

(define (main args)
  (if (null? args) (usage)
      (let-args (cdr args)
	  ([dpi   "dpi=i" 96 => (pa$ set-dpi)]
	   [pt?   "p|point"]
	   [mm?   "m|mm"]
	   [px?   "x|pixel"]
	   [Q?    "Q"]
	   [help? "h|help"]
	   [else (opt . _) (unknown-option opt)]
	   . restargs)
	(if (or help? (null? restargs)) (usage)
	    (let1 size (string->number (car restargs))
	      (if (not size) (not-number (car restargs))
		  (for-each print
			    ((cond [pt?  disp-pt-convert]
				   [mm?  disp-mm-convert]
				   [px?  disp-px-convert]
				   [else disp-Q-convert])
			     size)))))))
  0)
;; EOF