defmodule Krug.DistributedMnesiaMasterControlTask do

  @moduledoc false
  
  @verify_interval 300
  @connection_timeout 100
  
  
  
  use Task
  alias Krug.DistributedMnesiaMasterControl
  alias Krug.ClusterUtil
  alias Krug.NetworkUtil
  
  
  
  def start_link(_opts) do
    Task.start_link(__MODULE__, :correct_master_node, [])
  end
  
  
  
  def correct_master_node() do
    # ["correct_master_node .... "] |> IO.inspect()
    cond do
      (node_is_running(node()))
        -> verify_and_correct_master_node()
      true
        -> :ok # mnesia stopped
    end
  end
  
  
  
  defp verify_and_correct_master_node() do
    master_nodes = read_master_nodes()
    # ["master_nodes => ", master_nodes] |> IO.inspect()
    cond do
      (nil == master_nodes
        or Enum.empty?(master_nodes))
          -> find_and_set_new_mnesia_master_node()
      (!(master_nodes |> hd() |> node_is_running()))
        -> find_and_set_new_mnesia_master_node()
      true
        -> master_nodes 
             |> hd() 
             |> find_and_set_new_mnesia_master_node()
    end
    @verify_interval
      |> :timer.sleep()
  	correct_master_node()  
  end
  
  
  
  defp node_is_running(mnesia_node) do
    nil != mnesia_node |> read_master_nodes()
  end



  defp read_master_nodes(mnesia_node \\ node()) do
    params = [
      DistributedMnesiaMasterControl.read_metadata_table(),
      :master_nodes
    ]
    case :rpc.call(mnesia_node,:mnesia,:table_info,params,@connection_timeout) do
      {:badrpc, _reason} 
        -> nil
      master_nodes 
        -> master_nodes
    end
  end


  
  defp find_and_set_new_mnesia_master_node(actual_master_node \\ nil) do
    # ["find_and_set_new_mnesia_master_node"] |> IO.inspect()
    connected_nodes = reconnect_connected_nodes()
    :extra_db_nodes 
      |> :mnesia.change_config(connected_nodes)
    connected_nodes
      |> NetworkUtil.get_minor_node()
      |> set_master_node(actual_master_node)
  end


  
  defp set_master_node(node_to_be_new_master,actual_master_node) do
    # ["set_master_node",node_to_be_new_master] |> IO.inspect()
    cond do
      (node_to_be_new_master == actual_master_node)
        -> :ok
      (nil != node_to_be_new_master)
        -> [node_to_be_new_master] 
             |> :mnesia.set_master_nodes()
      true
        -> :ok
    end
  end



  defp reconnect_connected_nodes() do
    [
      _cluster_cookie,
      cluster_name,
      cluster_ips
    ] = DistributedMnesiaMasterControl.read_cluster_data()
    ClusterUtil.connect_nodes([],cluster_name,cluster_ips,@connection_timeout)
  end  


   
end