defmodule Khf2 do
  @moduledoc """
  Kemping térképe
  @author "Istvánfi Csenge <istvanfi.csenge@edu.bme.hu>"
  @date   "2023-09-28"
  ...

  EZ HELYES MOST!!!! (vagyis a legonkabb)
  """

  # sor száma (1-től n-ig)
  @type row :: integer
  # oszlop száma (1-től m-ig)
  @type col :: integer
  # egy parcella koordinátái
  @type field :: {row, col}

  # a sátrak száma soronként
  @type tents_count_rows :: [integer]
  # a sátrak száma oszloponként
  @type tents_count_cols :: [integer]

  # a fákat tartalmazó parcellák koordinátái lexikálisan rendezve
  @type trees :: [field]
  # a feladványleíró hármas
  @type puzzle_desc :: {tents_count_rows, tents_count_cols, trees}

  # a sátorpozíciók iránya: north, east, south, west
  @type dir :: :n | :e | :s | :w
  # a sátorpozíciók irányának listája a fákhoz képest
  @type tent_dirs :: [dir]

  @type matrix :: [[char()]]

  @spec make_empty_matrix(rows :: integer(), cols :: integer()) :: :matrix
  @spec to_external(pd :: puzzle_desc, ds :: tent_dirs) :: :ok
  # A pd = {rs, cs, ts} feladványleíró és a ds sátorirány-lista alapján
  # a feladvány szöveges ábrázolását írja ki a file fájlba, ahol
  #   rs a sátrak soronkénti számának a listája,
  #   cs a sátrak oszloponkénti számának a listája,
  #   ts a fákat tartalmazó parcellák koordinátájának listája
  @type all_coords :: [[]]


  def make_empty_matrix(rows, cols)
      when is_integer(rows) and is_integer(cols) and rows > 0 and cols > 0 do
    Enum.map(1..rows, fn _ ->
      Enum.map(1..cols, fn _ -> "-" end)
    end)
  end

  def fill_mx(matrix, tents_count_rows, tents_count_cols, trees, tent_dirs) do
    fill_matrix(matrix, tents_count_rows, tents_count_cols, trees, tent_dirs)
  end

  def fill_matrix(matrix, tents_count_rows, tents_count_cols, [], _tent_dirs)
      when is_list(matrix) do
    matrix
  end

  def fill_matrix(
        acc_matrix,
        tents_count_rows,
        tents_count_cols,
        [{row, col} | rest_trees],
        [dir | rest_dirs]
      ) do
  matrix_size = min(length(tents_count_rows), length(tents_count_cols)) # Minimumot veszünk a sorok és oszlopok között

    updated_mx =
      case dir do
        :e when col < matrix_size ->
          update_matrix(acc_matrix, row, col + 1, "E")

        :s when row < matrix_size ->
          update_matrix(acc_matrix, row + 1, col, "S")

        :n when row > 1 ->
          update_matrix(acc_matrix, row - 1, col, "N")

        :w when col > 1 ->
          update_matrix(acc_matrix, row, col - 1, "W")

        _ ->
          acc_matrix
      end

    matrix_with_tents_with_star = update_matrix(updated_mx, row, col, "*")


    fill_matrix(
      matrix_with_tents_with_star,
      tents_count_rows,
      tents_count_cols,
      rest_trees,
      rest_dirs
    )
  end

  def update_matrix(matrix, row, col, value) do
    Enum.with_index(matrix, fn r, i ->
      if i == row - 1 do
        Enum.with_index(r, fn cell, j ->
          if j == col - 1 do
            value
          else
            cell
          end
        end)
      else
        r
      end
    end)
  end

  def to_external({tents_count_rows, tents_count_cols, trees}, tent_dirs) do
    matrix = make_empty_matrix(length(tents_count_rows), length(tents_count_cols))
    matrix_with_tents = fill_mx(matrix, tents_count_rows, tents_count_cols, trees, tent_dirs)
    IO.inspect(matrix_with_tents)
  end
end

puzzle0 = {[-1, 0, 0, -3, 0], [0, 0, -2, 0, 0], []}
puzzle1 = {[1, 1, 0, 3, 0], [1, 0, 2, 0, 2], [{1, 2}, {3, 3}, {3, 5}, {5, 1}, {5, 5}]}
puzzle2 = {[1, 1, -1, 3, 0], [1, 0, -2, 0, 2], [{1, 2}, {3, 3}, {3, 5}, {5, 1}, {5, 5}]}
puzzle3 = {[2], [0, 1, -1, 0, -1], [{1, 1}, {1, 4}]}
puzzle4 = {[0, -1, 0, 1, 1, 0], [3], [{1, 1}, {3, 1}, {6, 1}]}
 Khf2.to_external(puzzle3, [:e, :e])

 Khf2.to_external(puzzle2,  [:e,:s,:n,:n,:w])

 Khf2.to_external(puzzle4,  [:s,:s,:n])
 Khf2.to_external(puzzle3, [:e,:e])