defprotocol Contex.PlotContent do
  @moduledoc """
  Defines what a charting component needs to implement to be rendered within a `Contex.Plot`
  """

  @doc """
  Generates svg as a string or improper list of strings *without* the SVG containing element.
  """
  def to_svg(plot, plot_options)

  @doc """
  Generates svg content for a legend appropriate for the plot content.
  """
  def get_legend_scales(plot)

  @doc """
  Sets the size for the plot content. This is called after the main layout and margin calculations
  are performed by the container plot.
  """
  def set_size(plot, width, height)
end

defmodule Contex.Plot do
  @moduledoc """
  Manages the layout of various plot elements, including titles, axis labels, legends etc and calculates
  appropriate margins depending on the options set.
  """
  import Contex.SVG
  alias __MODULE__
  alias Contex.{Dataset, PlotContent}

  defstruct [
    :title,
    :subtitle,
    :x_label,
    :y_label,
    :height,
    :width,
    :plot_content,
    :margins,
    :plot_options,
    default_style: true
  ]

  @type t() :: %__MODULE__{}
  @type plot_text() :: String.t() | nil
  @type row() :: list() | tuple()

  @default_plot_options [
    show_x_axis: true,
    show_y_axis: true,
    legend_setting: :legend_none
  ]

  @default_padding 10
  @top_title_margin 20
  @top_subtitle_margin 15
  @y_axis_margin 20
  @y_axis_tick_labels 70
  @legend_width 100
  @x_axis_margin 20
  @x_axis_tick_labels 70
  @default_style """
  <style type="text/css"><![CDATA[
    text {fill: black}
    line {stroke: black}
  ]]></style>
  """

  @doc """
  Creates a new plot with specified dataset and plot type. Other plot attributes can be set via a
  keyword list of options.
  """
  @spec new(Contex.Dataset.t(), module(), integer(), integer(), keyword()) :: Contex.Plot.t()
  def new(%Dataset{} = dataset, type, width, height, attrs \\ []) do
    # TODO
    # Seems like should just add new/3 to PlotContent protocol, but my efforts to do this failed.
    plot_content = apply(type, :new, [dataset, attrs])

    attributes =
      Keyword.merge(@default_plot_options, attrs)
      |> parse_attributes()

    %Plot{
      title: attributes.title,
      subtitle: attributes.subtitle,
      x_label: attributes.x_label,
      y_label: attributes.y_label,
      width: width,
      height: height,
      plot_content: plot_content,
      plot_options: attributes.plot_options
    }
    |> calculate_margins()
  end

  @doc """
  Creates a new plot with specified plot content.
  """
  @spec new(integer(), integer(), Contex.PlotContent.t()) :: Contex.Plot.t()
  def new(width, height, plot_content) do
    plot_options = %{show_x_axis: true, show_y_axis: true, legend_setting: :legend_none}

    %Plot{plot_content: plot_content, width: width, height: height, plot_options: plot_options}
    |> calculate_margins()
  end

  @doc """
  Replaces the plot dataset and updates the plot content. Accepts list of lists/tuples
  representing the new data and a list of strings with new headers.
  """
  @spec dataset(Contex.Plot.t(), list(row()), list(String.t())) :: Contex.Plot.t()
  def dataset(%Plot{} = plot, data, headers) do
    dataset = Dataset.new(data, headers)
    plot_content = apply(plot.plot_content.__struct__, :new, [dataset])
    %{plot | plot_content: plot_content}
  end

  @doc """
  Replaces the plot dataset and updates the plot content. Accepts a dataset or a list of lists/tuples
  representing the new data. The plot's dataset's original headers are preserved.
  """
  @spec dataset(Contex.Plot.t(), Contex.Dataset.t() | list(row())) :: Contex.Plot.t()
  def dataset(%Plot{} = plot, %Dataset{} = dataset) do
    plot_content = apply(plot.plot_content.__struct__, :new, [dataset])
    %{plot | plot_content: plot_content}
  end

  def dataset(%Plot{} = plot, data) do
    dataset =
      case plot.plot_content.dataset.headers do
        nil ->
          Dataset.new(data)

        headers ->
          Dataset.new(data, headers)
      end

    plot_content = apply(plot.plot_content.__struct__, :new, [dataset])
    %{plot | plot_content: plot_content}
  end

  @doc """
  Updates attributes for the plot. Takes a keyword list of attributes, which can include both "plot options"
  items passed individually as well as `:title`, `:subtitle`, `:x_label` and `:y_label`.
  """
  @spec attributes(Contex.Plot.t(), keyword()) :: Contex.Plot.t()
  def attributes(%Plot{} = plot, attrs) do
    attributes_map = Enum.into(attrs, %{})

    plot_options =
      Map.merge(
        plot.plot_options,
        Map.take(attributes_map, [:show_x_axis, :show_y_axis, :legend_setting])
      )

    plot
    |> Map.merge(
      Map.take(attributes_map, [:title, :subtitle, :x_label, :y_label, :width, :height])
    )
    |> Map.put(:plot_options, plot_options)
    |> calculate_margins()
  end

  @doc """
  Updates plot options for the plot.
  """
  def plot_options(%Plot{} = plot, new_plot_options) do
    existing_plot_options = plot.plot_options

    %{plot | plot_options: Map.merge(existing_plot_options, new_plot_options)}
    |> calculate_margins()
  end

  @doc """
  Sets the title and sub-title for the plot. Empty string or nil will remove the
  title or sub-title
  """
  @spec titles(Contex.Plot.t(), plot_text(), plot_text()) :: Contex.Plot.t()
  def titles(%Plot{} = plot, title, subtitle) do
    Plot.attributes(plot, title: title, subtitle: subtitle)
  end

  @doc """
  Sets the x-axis & y-axis labels for the plot. Empty string or nil will remove them.
  """
  @spec axis_labels(Contex.Plot.t(), plot_text(), plot_text()) :: Contex.Plot.t()
  def axis_labels(%Plot{} = plot, x_label, y_label) do
    Plot.attributes(plot, x_label: x_label, y_label: y_label)
  end

  @doc """
  Updates the size for the plot
  """
  @spec size(Contex.Plot.t(), integer(), integer()) :: Contex.Plot.t()
  def size(%Plot{} = plot, width, height) do
    Plot.attributes(plot, width: width, height: height)
  end

  @doc """
  Generates SVG output marked as safe for the configured plot.
  """
  def to_svg(%Plot{width: width, height: height, plot_content: plot_content} = plot) do
    %{left: left, right: right, top: top, bottom: bottom} = plot.margins
    content_height = height - (top + bottom)
    content_width = width - (left + right)

    x_tick_label_space = if plot.plot_options.show_x_axis, do: @x_axis_tick_labels, else: 0

    legend_scales = PlotContent.get_legend_scales(plot_content)
    legend_setting = plot.plot_options[:legend_setting]

    legend_left =
      case legend_setting do
        :legend_right -> left + content_width + @default_padding
        _ -> left
      end

    legend_top =
      case legend_setting do
        :legend_top -> top - legend_height(legend_scales)
        :legend_bottom -> top + content_height + @default_padding + x_tick_label_space
        _ -> top + @default_padding
      end

    plot_content = PlotContent.set_size(plot_content, content_width, content_height)

    output = [
      ~s|<svg version="1.1" xmlns="http://www.w3.org/2000/svg\" |,
      ~s|xmlns:xlink="http://www.w3.org/1999/xlink" class="chart" |,
      ~s|viewBox="0 0 #{width} #{height}" role="img">|,
      get_default_style(plot),
      get_titles_svg(plot, content_width),
      get_axis_labels_svg(plot, content_width, content_height),
      ~s|<g transform="translate(#{left},#{top})">|,
      PlotContent.to_svg(plot_content, plot.plot_options),
      "</g>",
      get_svg_legends(legend_scales, legend_left, legend_top, plot.plot_options),
      "</svg>"
    ]

    {:safe, output}
  end

  @doc """
  Generates a complete XML document string.
  """
  @spec to_xml(Contex.Plot.t()) :: iolist()
  def to_xml(%Plot{} = plot) do
    plot
    |> Plot.to_svg()
    |> elem(1)
    |> List.insert_at(0, ~s|<?xml version="1.0" encoding="utf-8"?>|)
  end

  defp get_default_style(%Plot{} = plot) do
    if plot.default_style, do: @default_style, else: ""
  end

  defp legend_height(scales) do
    Enum.reduce(scales, 0, fn scale, acc ->
      acc + Contex.Legend.height(scale)
    end)
  end

  defp get_svg_legends(scales, legend_left, legend_top, %{legend_setting: legend_setting})
       when legend_setting in [:legend_right, :legend_top, :legend_bottom] do
    draw_legends(scales, legend_left, legend_top)
  end

  defp get_svg_legends(_scales, _legend_left, _legend_top, _opts), do: ""

  defp draw_legends(scales, legend_left, legend_top) do
    {result, _top} =
      Enum.reduce(scales, {[], legend_top}, fn scale, {acc, top} ->
        legend = [
          ~s|<g transform="translate(#{legend_left}, #{top})">|,
          Contex.Legend.to_svg(scale),
          "</g>"
        ]

        {[legend | acc], top + Contex.Legend.height(scale)}
      end)

    result
  end

  defp get_titles_svg(
         %Plot{title: title, subtitle: subtitle, margins: margins} = _plot,
         content_width
       )
       when is_binary(title) or is_binary(subtitle) do
    centre = margins.left + content_width / 2.0
    title_y = @top_title_margin

    title_svg =
      case is_non_empty_string(title) do
        true ->
          text(centre, title_y, title, class: "exc-title", text_anchor: "middle")

        _ ->
          ""
      end

    subtitle_y =
      case is_non_empty_string(title) do
        true -> @top_subtitle_margin + @top_title_margin
        _ -> @top_subtitle_margin
      end

    subtitle_svg =
      case is_non_empty_string(subtitle) do
        true ->
          text(centre, subtitle_y, subtitle, class: "exc-subtitle", text_anchor: "middle")

        _ ->
          ""
      end

    [title_svg, subtitle_svg]
  end

  defp get_titles_svg(_, _), do: ""

  defp get_axis_labels_svg(
         %Plot{x_label: x_label, y_label: y_label, margins: margins} = _plot,
         content_width,
         content_height
       )
       when is_binary(x_label) or is_binary(y_label) do
    x_label_x = margins.left + content_width / 2.0
    x_label_y = margins.top + content_height + @x_axis_tick_labels

    # -90 rotation screws with coordinates
    y_label_x = -1.0 * (margins.top + content_height / 2.0)
    y_label_y = @y_axis_margin

    x_label_svg =
      case is_non_empty_string(x_label) do
        true ->
          text(x_label_x, x_label_y, x_label, class: "exc-subtitle", text_anchor: "middle")

        _ ->
          ""
      end

    y_label_svg =
      case is_non_empty_string(y_label) do
        true ->
          text(y_label_x, y_label_y, y_label,
            class: "exc-subtitle",
            text_anchor: "middle",
            transform: "rotate(-90)"
          )

        false ->
          ""
      end

    [x_label_svg, y_label_svg]
  end

  defp get_axis_labels_svg(_, _, _), do: ""

  defp parse_attributes(attrs) do
    %{
      title: Keyword.get(attrs, :title),
      subtitle: Keyword.get(attrs, :subtitle),
      x_label: Keyword.get(attrs, :x_label),
      y_label: Keyword.get(attrs, :y_label),
      plot_options:
        Enum.into(Keyword.take(attrs, [:show_x_axis, :show_y_axis, :legend_setting]), %{})
    }
  end

  defp calculate_margins(%Plot{} = plot) do
    legend_scales = PlotContent.get_legend_scales(plot.plot_content)

    left = Map.get(plot.plot_options, :left_margin, calculate_left_margin(plot))

    top =
      Map.get(
        plot.plot_options,
        :top_margin,
        calculate_top_margin(plot, legend_height(legend_scales))
      )

    right = Map.get(plot.plot_options, :right_margin, calculate_right_margin(plot))

    bottom =
      Map.get(
        plot.plot_options,
        :bottom_margin,
        calculate_bottom_margin(plot, legend_height(legend_scales))
      )

    margins = %{left: left, top: top, right: right, bottom: bottom}

    %{plot | margins: margins}
  end

  defp calculate_left_margin(%Plot{} = plot) do
    margin = 0
    margin = margin + if plot.plot_options.show_y_axis, do: @y_axis_tick_labels, else: 0
    margin = margin + if is_non_empty_string(plot.y_label), do: @y_axis_margin, else: 0

    margin
  end

  defp calculate_right_margin(%Plot{} = plot) do
    margin = @default_padding

    margin =
      margin + if plot.plot_options.legend_setting == :legend_right, do: @legend_width, else: 0

    margin
  end

  defp calculate_bottom_margin(%Plot{} = plot, legend_height) do
    margin = 0
    margin = margin + if plot.plot_options.show_x_axis, do: @x_axis_tick_labels, else: 0
    margin = margin + if is_non_empty_string(plot.x_label), do: @x_axis_margin, else: 0

    margin =
      margin + if plot.plot_options.legend_setting == :legend_bottom, do: legend_height, else: 0

    margin
  end

  defp calculate_top_margin(%Plot{} = plot, legend_height) do
    margin = @default_padding

    margin =
      margin +
        if is_non_empty_string(plot.title), do: @top_title_margin + @default_padding, else: 0

    margin = margin + if is_non_empty_string(plot.subtitle), do: @top_subtitle_margin, else: 0

    margin =
      margin + if plot.plot_options.legend_setting == :legend_top, do: legend_height, else: 0

    margin
  end

  defp is_non_empty_string(val) when is_nil(val), do: false
  defp is_non_empty_string(val) when val == "", do: false
  defp is_non_empty_string(val) when is_binary(val), do: true
  defp is_non_empty_string(_), do: false
end

# TODO: Probably move to appropriate module files...
defimpl Contex.PlotContent, for: Contex.BarChart do
  def to_svg(plot, options), do: Contex.BarChart.to_svg(plot, options)
  def get_legend_scales(plot), do: Contex.BarChart.get_legend_scales(plot)
  def set_size(plot, width, height), do: Contex.BarChart.set_size(plot, width, height)
end

defimpl Contex.PlotContent, for: Contex.PointPlot do
  def to_svg(plot, options), do: Contex.PointPlot.to_svg(plot, options)
  def get_legend_scales(plot), do: Contex.PointPlot.get_legend_scales(plot)
  def set_size(plot, width, height), do: Contex.PointPlot.set_size(plot, width, height)
end

defimpl Contex.PlotContent, for: Contex.LinePlot do
  def to_svg(plot, options), do: Contex.LinePlot.to_svg(plot, options)
  def get_legend_scales(plot), do: Contex.LinePlot.get_legend_scales(plot)
  def set_size(plot, width, height), do: Contex.LinePlot.set_size(plot, width, height)
end

defimpl Contex.PlotContent, for: Contex.GanttChart do
  def to_svg(plot, options), do: Contex.GanttChart.to_svg(plot, options)
  # Contex.PointPlot.get_legend_svg(plot)
  def get_legend_scales(_plot), do: []
  def set_size(plot, width, height), do: Contex.GanttChart.set_size(plot, width, height)
end

defimpl Contex.PlotContent, for: Contex.PieChart do
  def to_svg(plot, _options), do: Contex.PieChart.to_svg(plot)
  def get_legend_scales(plot), do: Contex.PieChart.get_legend_scales(plot)
  def set_size(plot, width, height), do: Contex.PieChart.set_size(plot, width, height)
end