# frozen_string_literal: true

require 'intranet/core'
require 'intranet/logger'
require 'intranet/abstract_responder'
require 'intranet/pandoc/responder'

RSpec.describe Intranet::Pandoc::Responder do
  it 'should inherit from Intranet::AbstractResponder' do
    expect(described_class.superclass).to eql(Intranet::AbstractResponder)
  end

  it 'should define its name, version and homepage' do
    expect { described_class.module_name }.not_to raise_error
    expect { described_class.module_version }.not_to raise_error
    expect { described_class.module_homepage }.not_to raise_error
  end

  before do
    logger = Intranet::Logger.new(Intranet::Logger::FATAL)
    @core = Intranet::Core.new(logger)

    testroot = File.absolute_path('testroot', __dir__)
    @template = File.join(testroot, 'template.html')
    @responder = described_class.new(logger, 'TITLE', testroot, nil)
    @core.register_module(
      @responder, ['pandoc'], File.absolute_path('../../../lib/intranet/resources', __dir__)
    )
  end

  describe '#in_menu?' do
    it 'should return the value provided at initialization' do
      expect(described_class.new(nil, '', nil, nil, false).in_menu?).to be false
      expect(described_class.new(nil, '', nil, nil, true).in_menu?).to be true
    end
  end

  describe '#resources_dir' do
    it 'should return the absolute path of the resources directory' do
      expect(described_class.new(nil, '', nil, false).resources_dir).to eql(
        File.absolute_path('../../../lib/intranet/resources', __dir__)
      )
    end
  end

  describe '#title' do
    it 'should return the title of the webpage provided by the module' do
      expect(@responder.title).to eql('TITLE')
    end
  end

  describe '#generate_page' do
    context 'when asked for an existing HTML page' do
      it 'should return a partial HTML content generated from the index.md file' do
        code, mime, content = @responder.generate_page('/index.html', {})
        expect(code).to eql(206)
        expect(mime).to eql('text/html')
        expect(content).to eql(
          {
            content: '<section>' \
                     "<p>This is index.md, the main markdown page.</p>\n" \
                     "<p>We may use the following text attributes:</p>\n" \
                     "<ul>\n" \
                     "<li><em>italic</em></li>\n" \
                     "<li><strong>bold</strong></li>\n" \
                     "<li><code>monospace</code></li>\n" \
                     "</ul>\n" \
                     "<p>We may produce an horizontal rule:</p>\n" \
                     "<hr />\n" \
                     "<p>Two spaces at the end of a line<br />\nproduce a line break.</p>\n" \
                     "<blockquote>\n" \
                     "<p>Markdown uses email-style characters for blockquoting.</p>\n" \
                     "<p>Multiple paragraphs need to be prepended individually.</p>\n" \
                     "</blockquote>\n" \
                     '</section>',
            title: 'TITLE',
            stylesheets: ['design/style.css'],
            scripts: []
          }
        )
      end

      it 'should shift titles by one level to correctly fit in intranet page template' do
        code, mime, content = @responder.generate_page('/filters/test-titles-shift-levels.html', {})
        expect(code).to eql(206)
        expect(mime).to eql('text/html')
        expect(content).to eql(
          {
            content: '<section>' \
                     "<h2 id=\"level-1-heading\">Level-1 Heading</h2>\n" \
                     "<h3 id=\"level-2-heading\">Level-2 Heading</h3>\n" \
                     "<h2 id=\"alternative-level-1-heading\">Alternative Level-1 heading</h2>\n" \
                     "<h3 id=\"alternative-level-2-heading\">Alternative Level-2 heading</h3>\n" \
                     "<h4 id=\"level-3-heading\">Level-3 heading</h4>\n" \
                     "<p>Other heading levels are not supported by pandoc markdown.</p>\n" \
                     '</section>',
            title: 'TITLE',
            stylesheets: ['design/style.css'],
            scripts: []
          }
        )
      end

      it 'should add the _blank attributes to external links' do
        code, mime, content = @responder.generate_page('/filters/test-links-open-external-in-new-tab.html', {})
        expect(code).to eql(206)
        expect(mime).to eql('text/html')
        expect(content).to eql(
          {
            content: '<section>' \
                     "<p>We use a filter that may produce:</p>\n" \
                     "<ul>\n" \
                     "<li><a href=\"index.html\">relative internal links</a></li>\n" \
                     "<li><a href=\"/index.html\">absolute internal links</a></li>\n" \
                     "<li><a href=\"http://example.com\" target=\"_blank\">HTTP external\nlinks</a></li>\n" \
                     "<li><a href=\"https://example.com\" target=\"_blank\">HTTPS external\nlinks</a></li>\n" \
                     "</ul>\n" \
                     '</section>',
            title: 'TITLE',
            stylesheets: ['design/style.css'],
            scripts: []
          }
        )
      end

      it 'should use the specified template, if any, to generate the partial HTML content' do
        @responder.instance_variable_set(:@template, @template)
        code, mime, content = @responder.generate_page('/index.html', {})
        expect(code).to eql(206)
        expect(mime).to eql('text/html')
        expect(content).to eql(
          {
            content: '<section>' \
                     "<p>This page was generated using <code>template.html</code>.</p>\n" \
                     "\n" \
                     "<p>This is index.md, the main markdown page.</p>\n" \
                     "<p>We may use the following text attributes:</p>\n" \
                     "<ul>\n" \
                     "<li><em>italic</em></li>\n" \
                     "<li><strong>bold</strong></li>\n" \
                     "<li><code>monospace</code></li>\n" \
                     "</ul>\n" \
                     "<p>We may produce an horizontal rule:</p>\n" \
                     "<hr />\n" \
                     "<p>Two spaces at the end of a line<br />\nproduce a line break.</p>\n" \
                     "<blockquote>\n" \
                     "<p>Markdown uses email-style characters for blockquoting.</p>\n" \
                     "<p>Multiple paragraphs need to be prepended individually.</p>\n" \
                     "</blockquote>\n" \
                     "\n" \
                     "<p>End of template</p>\n" \
                     '</section>',
            title: 'TITLE',
            stylesheets: ['design/style.css'],
            scripts: []
          }
        )
      end
    end

    context 'when asked for an existing picture' do
      it 'should return the picture' do
        # JPG file
        code, mime, content = @responder.generate_page('/white.jpg', {})
        expect(code).to eql(200)
        expect(mime).to eql('image/jpeg')
        expect(content).to eql(File.read(File.join(__dir__, 'testroot', 'white.jpg')))

        # PNG file
        code, mime, content = @responder.generate_page('/alpha.png', {})
        expect(code).to eql(200)
        expect(mime).to eql('image/png')
        expect(content).to eql(File.read(File.join(__dir__, 'testroot', 'alpha.png')))

        # SVG file
        code, mime, content = @responder.generate_page('/decimal.svg', {})
        expect(code).to eql(200)
        expect(mime).to eql('image/svg+xml')
        expect(content).to eql(File.read(File.join(__dir__, 'testroot', 'decimal.svg')))
      end
    end

    context 'otherwise' do
      it 'should return an HTTP 404 error' do
        expect(@responder.generate_page('/filters/index.html', {})).to eql([404, '', ''])
        expect(@responder.generate_page('index.html', {})).to eql([404, '', ''])
        expect(@responder.generate_page('/black.jpg', {})).to eql([404, '', ''])
      end
    end
  end
end