#:use-module (tools haunt-i18n)

  #:use-module (tools haunt-i18n)

  #:use-module (tools haunt-i18n)

  #:use-module (tools haunt-i18n)

  #:use-module (tools haunt-i18n)

  #:use-module (tools haunt-i18n)

  #:use-module (tools haunt-i18n)

;;; Nani Project website

;;; Copyright ?? 2019 Julien Lepiller <julien@lepiller.eu>

;;;

;;; This file is part of the Nani Project website.

;;;

;;; The Nani Project website is free software; you can redistribute it and/or modify it

;;; under the terms of the GNU Affero General Public License as published by

;;; the Free Software Foundation; either version 3 of the License, or (at

;;; your option) any later version.

;;;

;;; The Nani Project website is distributed in the hope that it will be useful, but

;;; WITHOUT ANY WARRANTY; without even the implied warranty of

;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

;;; GNU Affero General Public License for more details.

;;;

;;; You should have received a copy of the GNU Affero General Public License

;;; along with the Nani Project website.  If not, see <http://www.gnu.org/licenses/>.

(define-module (tools haunt-i18n)

  #:use-module (haunt builder blog)

  #:use-module (haunt html)

  #:use-module (haunt page)

  #:use-module (sxml simple)

  #:use-module (ice-9 match)

  #:use-module (tools i18n)

  #:export (internationalize))

(define (make-my-page lang title filename body layout)

  (lambda (site posts)

    (define (my-body)

      (site-locale lang)

      (tr body))

    (make-page (if (equal? lang "")

                 (string-append filename ".html")

                 (string-append filename "." lang ".html"))

               (with-layout (layout lang filename) site title (my-body))

               sxml->html)))

(define (internationalize title filename body layout)

  (map (lambda (lang) (make-my-page lang title filename body layout)) languages))

  #:export (languages tr _ site-locale translate))

      ((*TOP* (tr rest ...)) (car rest)))))

    (('_ rest) (_ rest))

(define (translate str lang)

  (site-locale lang)

  (tr str))

  (call-with-input-file input

    (lambda (port)

      (xml->results port frq))))

;;; Nani Project website

;;; Copyright ?? 2020 Julien Lepiller <julien@lepiller.eu>

;;;

;;; This file is part of the Nani Project website.

;;;

;;; The Nani Project website is free software; you can redistribute it and/or modify it

;;; under the terms of the GNU Affero General Public License as published by

;;; the Free Software Foundation; either version 3 of the License, or (at

;;; your option) any later version.

;;;

;;; The Nani Project website is distributed in the hope that it will be useful, but

;;; WITHOUT ANY WARRANTY; without even the implied warranty of

;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

;;; GNU Affero General Public License for more details.

;;;

;;; You should have received a copy of the GNU Affero General Public License

;;; along with the Nani Project website.  If not, see <http://www.gnu.org/licenses/>.

(use-modules (tools i18n))

(use-modules (nani radk))

(use-modules (nani jmdict serialize))

(use-modules (gcrypt hash))

(use-modules (ice-9 match))

(use-modules (ice-9 format))

(use-modules (ice-9 binary-ports))

(define* (description dico #:key (long? #f) (lang "en"))

  (define radk-synopsis

    `(_ "Radical to Kanji dictionary from the Electronic Dictionary Research and Development Group."))

  (define radk-description

    `(_ "This dictionary allows you to enter kanji by selecting some of its

    components.  Tap the water component button on the bottom of the screen to

    access the kanji selection by component view"))

  (define (jmdict-synopsis lang)

    (match lang

      ("e" `(_ "Japanese/English dictionary from the Electronic Dictionary Research and Development Group."))

      ("dut" `(_ "Japanese/Dutch dictionary from the Electronic Dictionary Research and Development Group."))

      ("fre" `(_ "Japanese/French dictionary from the Electronic Dictionary Research and Development Group."))

      ("ger" `(_ "Japanese/German dictionary from the Electronic Dictionary Research and Development Group."))

      ("hun" `(_ "Japanese/Hungarian dictionary from the Electronic Dictionary Research and Development Group."))

      ("rus" `(_ "Japanese/Russian dictionary from the Electronic Dictionary Research and Development Group."))

      ("slv" `(_ "Japanese/Slovenian dictionary from the Electronic Dictionary Research and Development Group."))

      ("spa" `(_ "Japanese/Spanish dictionary from the Electronic Dictionary Research and Development Group."))

      ("swe" `(_ "Japanese/Swedish dictionary from the Electronic Dictionary Research and Development Group."))))

  (define (jmdict-description lang)

    `(_ "This dictionary allows you to do searches on the main view of this app.

        Failing to download one of these dictionaries will make the app unusable

        as you can't search for anything.  This dictionary can be searched for by

        kanji, reading (kana) and by meaning in the languages you selected."))

  (let* ((english

          (cond

            ((equal? (dico-type dico) "radk")

             (if long?

                 radk-description

                 radk-synopsis))

            ((equal? (dico-type dico) "jmdict")

             (let ((dico-lang (substring dico 7)))

               (if long?

                   (jmdict-description dico-lang)

                   (jmdict-synopsis dico-lang))))))

         (translated (translate english lang)))

    (if (and (equal? english translated) (not (equal? lang "en")))

        #f

        translated)))

(define (filesize file)

  (stat:size (stat file)))

(define (sha256 file)

  (define hash (file-sha256 file))

  (apply

    string-append

    (map

      (lambda (n)

        (format #f "~2,'0x" n))

      (array->list hash))))

(define (dico-type file)

  (cond

    ((equal? file "radicals") "radk")

    ((and (> (string-length file) 6) (equal? (substring file 0 6) "JMdict"))

     "jmdict")))

(define (entries file)

  (cond

    ((equal? (dico-type (dico-name file)) "radk")

     (kanji-count file))

    ((equal? (dico-type (dico-name file)) "jmdict")

     (jmdict-entry-count file))))

(define (dico-name file)

  (basename file ".nani"))

(match (command-line)

  ((_ output dicos ...)

   (with-output-to-file output

     (lambda _

       (for-each

         (lambda (dico)

           (let* ((sha256 (sha256 dico))

                  (size (filesize dico))

                  (name (dico-name dico))

                  (type (dico-type name))

                  (entry-count (entries dico)))

             (format #t "[~a]~%" name)

             (for-each

               (lambda (lang)

                 (let ((synopsis (description name #:lang lang))

                       (description (description name #:lang lang #:long? #t)))

                   (when synopsis

                     (format #t "synopsis=~a=~a~%" lang synopsis))

                   (when description

                     (format #t "description=~a=~a~%" lang description))))

               (filter (lambda (lang) (not (equal? lang ""))) languages))

             (format #t "sha256=~a~%" sha256)

             (format #t "size=~a~%" size)

             (format #t "type=~a~%" type)

             (format #t "entries=~a~%" entry-count)

             (format #t "url=~a~%" (string-append "https://nani.lepiller.eu/" dico))

             (format #t "~%")))

         dicos)))))

  #:use-module (tools haunt-i18n)

;;; Nani Project website

;;; Copyright ?? 2019 Julien Lepiller <julien@lepiller.eu>

;;;

;;; This file is part of the Nani Project website.

;;;

;;; The Nani Project website is free software; you can redistribute it and/or modify it

;;; under the terms of the GNU Affero General Public License as published by

;;; the Free Software Foundation; either version 3 of the License, or (at

;;; your option) any later version.

;;;

;;; The Nani Project website is distributed in the hope that it will be useful, but

;;; WITHOUT ANY WARRANTY; without even the implied warranty of

;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

;;; GNU Affero General Public License for more details.

;;;

;;; You should have received a copy of the GNU Affero General Public License

;;; along with the Nani Project website.  If not, see <http://www.gnu.org/licenses/>.

(use-modules (nani jmdict trie))

(use-modules (nani jmdict serialize))

(use-modules (nani wadoku xml))

(use-modules (nani frequency))

(use-modules (nani trie))

(use-modules (nani result))

(use-modules (ice-9 match))

(use-modules (ice-9 binary-ports))

;; Break these steps to try and let the GC reclaim these big objects

(define (get-results1 input frq)

  (call-with-input-file input

    (lambda (port)

      (xml->results port frq))))

(define (get-results input sense-filter frq)

  (let* ((results (get-results1 input frq))

         (results (map (lambda (result)

                         (update-result

                           result

                           #:senses (filter sense-filter

                                            (result-senses result))))

                       results))

         (results (filter (lambda (result) (not (null? (result-senses result))))

                          results)))

    (pk (car results))

    (let ((readings (apply append (map result-readings results))))

      (pk (apply append (map reading-readings readings))))

    results))

(define (compile input sense-filter output)

  (let* ((results (get-results input sense-filter

                               (load-frequency "dictionaries/frequency.tsv")))

         (kanji-trie (compress-trie (make-kanji-trie results)))

         (reading-trie (compress-trie (make-reading-trie results)))

         (meaning-trie (compress-trie (make-meaning-trie results))))

    (format #t "Number of entries in ~a: ~a~%" output (length results))

    (call-with-output-file output

      (lambda (port)

        (put-bytevector port

          (serialize-jmdict results kanji-trie reading-trie meaning-trie))))))

(define (print word dict)

  #t)

(match (command-line)

  ((_ cmd input lang output)

   (cond

    ((equal? cmd "build")

     (if (equal? lang "e")

       (compile input (const #t) output)

       (compile input (lambda (sense) (equal? (sense-language sense) lang)) output)))

    ((equal? cmd "convert")

     (convert input output))

    (else (format #t "Unknown cmd ~a.~%" cmd))))

  ((_ "print" word input)

   (print word input)))