epub_update

#!/usr/bin/env ruby
# frozen_string_literal: true

# Script takes a list of EPUBs, determines the list of
# CSS stylesheets and outputs info about each, and
# possibly replaces stylesheets

require 'optparse'
require 'ostruct'
require 'os'

# Determine the root directory of the code base.
script_dir = File.expand_path(File.dirname(__FILE__))
root_dir = File.dirname(script_dir)

require_relative File.join(root_dir, "lib", "logger")

script_logger = UMPTG::Logger.create(logger_fp: STDOUT)

# Process the script parameters.
options = OpenStruct.new
options.css_file_list = []
options.manifest_item_file_list = []
options.force_update = false
options.license = nil
options.monograph_metadata_file = nil
options.section_type = false
option_parser = OptionParser.new do |opts|
  opts.banner = "Usage: #{File.basename(__FILE__)} [-f] [-c css_file] [-l license] [-m manifest_item] [-r metadata_file] [-y] epub_file [epub_file...]"
  opts.on('-c', '--css [css_file]', 'CSS replacement') do |css_file|
    options.css_file_list << css_file
  end
  opts.on('-f', '--force-update', 'CSS force update') do |flag|
    options.force_update = true
  end
  opts.on('-l', '--license [license]', 'License') do |license|
    options.license = license
  end
  opts.on('-m', '--manifest_item item_file', 'Manifest item') do |item_file|
    options.manifest_item_file_list << item_file
  end
  opts.on('-r', '--monograph_metadata_file [metadata_file]', 'Monograph metadata file') do |item_file|
    options.monograph_metadata_file = item_file
  end
  opts.on('-y', '--section-type', 'Section roles/types') do |flag|
    options.section_type = true
  end
  opts.on_tail('-h', '--help', 'Print this help message') do
    script_logger.info(opts)
    exit 0
  end
end
option_parser.parse!(ARGV)
if ARGV.count < 1
  script_logger.info(option_parser.help)
  return
end
epub_file_list = ARGV

require_relative File.join(root_dir, 'lib', 'review')
require_relative File.join(root_dir, 'lib', 'csvfile')

unless options.license.nil?
  # Determine is license badge is available
  lic_file = Dir.glob(File.join(root_dir, "lib", "license", "cc_badges", "cc_" + options.license + ".xhtml")).first
  if lic_file.nil?
    script_logger.error("CC badge #{options.license} is not found.")
    exit(1)
  end
  script_logger.info("CC badge #{options.license} found.")
end

metadata_csv = nil
unless options.monograph_metadata_file.nil?
  metadata_csv = UMPTG::CSVFile.read(csv_path: options.monograph_metadata_file)
  script_logger.info("using metadata file #{options.monograph_metadata_file} found.")
end

epub_updater = UMPTG::Review::EPUBUpdater.new(
      logger: script_logger
      )

# Travese the list of EPUB files to update.
epub_file_list.each do |epub_file|
  epub_file = File.expand_path(epub_file)
  unless File.exist?(epub_file)
    script_logger.error("invalid EPUB file path #{epub_file}.")
    next
  end
  script_logger.info("*** processing #{File.basename(epub_file)} ***")
  STDOUT.flush

  epub = UMPTG::EPUB::Archive.new(epub_file: epub_file)

  unless options.css_file_list.empty?
    epub_updater.update_css(
        epub: epub,
        css_file_list: options.css_file_list,
        css_force_update: options.force_update,
        )
  end

  manifest_item_list = []
  failed = false
  options.manifest_item_file_list.each do |manifest_item_file|
    manifest_item_file = File.expand_path(manifest_item_file)
    unless File.exist?(manifest_item_file)
      script_logger.info("manifest file does not exist #{manifest_item_file}")
      next
    end

    unless File.extname(manifest_item_file) == ".xhtml"
      manifest_item_list << manifest_item_file
      next
    end

    xml_doc = Nokogiri::XML(File.read(manifest_item_file))
    img_file_list = []
    xml_doc.xpath("//*[local-name()='img']").each do |img_node|
      src = img_node['src']
      img_file = File.expand_path(src, File.dirname(manifest_item_file))
      unless File.exist?(img_file)
        script_logger.error("image file #{img_file} not found in manifest item #{manifest_item_file}")
        failed = true
        next
      end
      img_file_list << img_file
    end
    next if failed

    #manifest_item_list << manifest_item_file
    manifest_item_list += img_file_list
    puts img_file_list
  end
  next if failed

  metadata_row = nil
  unless metadata_csv.nil?
    bname = File.basename(epub_file)
    metadata_row = metadata_csv.find {|r| r['Monograph ID'] == bname }
    if metadata_row.nil?
      script_logger.warn("metadata row not found #{bname}.")
    else
      script_logger.info("metadata row found #{bname}.")
    end
  end

  cc_lic = options.license
  unless metadata_row.nil?
    cc = metadata_row['CC License']
    m = cc.match(/\/licenses\/([^\/]+)\//)
    if m.nil?
      script_logger.warn("license #{cc} not found.")
    else
      cc_lic = m[1].gsub(/\-/, '_')
      script_logger.info("license #{cc_lic} found.")
    end
  end
  unless cc_lic.nil?
    license_badge_file = File.join(root_dir, "lib", "license", "cc_badges", "cc_" + cc_lic + ".png")
    manifest_item_list << license_badge_file if File.exist?(license_badge_file)
  end

  manifest_item_list.each do |manifest_item_file|
    manifest_item_file = File.expand_path(manifest_item_file)
    script_logger.info("adding manifest item #{manifest_item_file}")

    epub_updater.add_item(
        epub: epub,
        item_file: manifest_item_file,
        spine_loc: 2
        )
  end

  unless cc_lic.nil? and !options.section_type
    # Process the epub and generate the image information.
    epub_reviewer = UMPTG::Review::EPUBReviewer.new(
          epub: epub,
          logger: script_logger
        )

    unless cc_lic.nil?
      license_fragment = nil

      license_file = File.join(root_dir, "lib", "license", "cc_badges", "cc_" + cc_lic + ".xhtml")
      if File.exist?(license_file)
        script_logger.info("using CC license file #{File.basename(license_file)}.")
        license_doc = Nokogiri::XML(File.read(license_file))
        license_fragment = license_doc.xpath("//*[local-name()='body']").first

        unless metadata_csv.nil?
          bname = File.basename(epub_file)
          mrow = metadata_csv.find {|r| r['Monograph ID'] == bname }
          unless mrow.nil?
=begin
            doi = mrow['DOI']
            frag = Nokogiri::XML::DocumentFragment.parse("<p id='doi'>DOI: <a href=\"#{doi}\">#{doi}</a></p>")
            license_fragment.add_child(frag)
=end

            oa_isbn_list = []
            ebook_isbn_list = []
            mrow['ISBN(s)'].split(';').each do |s|
              s.strip!
              m = s.match(/\(([^\)]+)\)/)
              next if m.nil?

              m[1].downcase!
              if m[1] == 'open access' or m[1].start_with?('oa ')
                oa_isbn_list << "ISBN: #{s}"
              elsif m[1].start_with?('ebook')
                ebook_isbn_list << "ISBN: #{s}"
              end
            end

            if !oa_isbn_list.empty?
              script_logger.info("using OA ISBNs.")
              isbn_markup = oa_isbn_list.join('<br/>')
            elsif !ebook_isbn_list.empty?
              script_logger.warn("using ebook ISBNs.")
              isbn_markup = ebook_isbn_list.join('<br/>')
            else
              script_logger.warn("no OA/ebook ISBNs found.")
              isbn_markup = ""
            end
            frag = Nokogiri::XML::DocumentFragment.parse("#{isbn_markup}")
            oa_node = license_fragment.xpath("//*[@id='isbn_open_access']").first
            oa_node.add_child(frag) unless oa_node.nil?
          end
        end
      else
        script_logger.warn("CC license file #{File.basename(license_file)} does not exist.")
      end

      epub_reviewer.review(
            review_options: { add_license: true },
            license_file: license_badge_file,
            license_fragment: license_fragment,
            normalize: true
          )
      action_map = epub_reviewer.action_map
    end

    if options.section_type
      epub_reviewer.review(
            review_options: { section_type: true }
          )
    end
  end

  if epub.modified
    epub_reviewer = UMPTG::Review::EPUBReviewer.new(
          epub: epub,
          logger: script_logger
        )

    epub_reviewer.review(
          review_options: { fix_img_ref: true },
          normalize: true
        )

    # EPUB updated. Save it to a new file.
    new_epub_file = File.join(File.dirname(epub_file), File.basename(epub_file, ".*") + "_replace" + File.extname(epub_file))
    script_logger.info("EPUB updated. Writing new EPUB file #{File.basename(new_epub_file)}")
    epub.save(epub_file: new_epub_file)
  else
    # No EPUB updates.
    script_logger.info("no updates for EPUB file #{File.basename(epub_file)}")
  end

  script_logger.info()
  STDOUT.flush
end
script_logger.info("#{File.basename(__FILE__)} processing completed.")