defmodule LSG.IRC.AlcoologPlugin do
  require Logger

  @moduledoc """
  # [alcoolog]({{context_path}}/alcoolog)

  * **!santai `<cl | (calc)>` `<degrés d'alcool> [annotation]`**: enregistre un nouveau verre de `montant` d'une boisson à `degrés d'alcool`.
  * **!santai `<cl | (calc)>` `<beer name>`**: enregistre un nouveau verre de `cl` de la bière `beer name`, et checkin sur Untappd.com.
  * **!moar `[cl]` : enregistre un verre équivalent au dernier !santai.
  * **-santai**: annule la dernière entrée d'alcoolisme.
  * **.alcoolisme**: état du channel en temps réel.
  * **.alcoolisme `<semaine | Xj>`**: points par jour, sur X j.
  * **!alcoolisme `[pseudo]`**: affiche les points d'alcoolisme.
  * **!alcoolisme `[pseudo]` `<semaine | Xj>`**: affiche les points d'alcoolisme par jour sur X j.
  * **+alcoolisme `<h|f>` `<poids en kg>` `[facteur de perte en mg/l (10, 15, 20, 25)]`**: Configure votre profil d'alcoolisme.
  * **.sobre**: affiche quand la sobriété frappera sur le chan.
  * **!sobre `[pseudo]`**: affiche quand la sobriété frappera pour `[pseudo]`.
  * **!sobrepour `<date>`**: affiche tu pourras être sobre pour `<date>`, et si oui, combien de volumes d'alcool peuvent encore être consommés.
  * **!alcoolog**: ([voir]({{context_path}}/alcoolog)) lien pour voir l'état/statistiques et historique de l'alcoolémie du channel.
  * **!alcool `<cl>` `<degrés>`**: donne le nombre d'unités d'alcool dans `<cl>` à `<degrés>°`.
  * **!soif**: c'est quand l'apéro ?

  1 point = 1 volume d'alcool.

  Annotation: champ libre!

  """

  @user_states %{
    :sober => %{
      false => ["n'a pas encore bu", "est actuellement sobre"],
      true => ["commence a peine... santé"],
    },
    :low => %{
      false => ["est quasiment sobre", "est entrain de redescendre et devrait reboire"],
      true => ["commence a monter"],
    },
    :legal => %{
      true => ["peut encore conduire, mais plus pour longtemps"],
      false => ["peut reconduire", "est en route vers la sobriété"],
    },
    :legalhigh => %{
      true => ["est bientôt bourraide", "peut plus conduire"],
      false => ["commence a débourrai"],
    },
    :high => %{
      true => ["est bourraide!", "est raide"],
      false => ["est bourraide mais redescend!"],
    },
    :toohigh => ["est totalement bourraide", "est raiiideeeeee"],
    :sick => ["est BEAUCOUP trop bourraide"],
  }


  @santai [
    "SANTÉ",
    "SANTAIIII",
    "SANTAI",
    "A LA TIENNE",
    "CUL SEC CUL SEC",
    "TCHIN TCHIN",
    "LONGUE VIE",
    "ZUM WOHL", "PROST",
    "Կէնաձդ",
    "Наздраве",
    "SANTAIIIIIIIIII",
    "AGLOU",
    "AUNG MYIN PAR SAY",
    "SALUD",
    "SANTAIIIIII",
    "ΥΓΕΙΑ",
    "Å’KåLÀ MA’LUNA",
    "EGÉSZSÉGEDRE",
    "FENÉKIG",
    "乾杯",
    "KANPAI",
    "TULGATSGAAYA",
    "AGLOU AGLOU",
    "БУДЕМ ЗДОРОВЫ",
    "НА ЗДОРОВЬЕ",
    "SANTAIIIIIIIIIIIII",
    "MỘT HAI BA, YO",
    "SKÅL",
    "NA ZDRAVJE",
    "AGLOUUUU AGLOUUU AGLOUUUUUUU",
    "فى صحتك",
    "GESONDHEID",
    "ZHU NIN JIANKANG",
    "祝您健康",
    "SANTÉ",
    "CHEERS",
    "Nuş olsun",
    "Živjeli",
    "Biba",
    "Pura vida",
    "Terviseks",
    "Mabuhay",
    "Kippis",
    "Sláinte",
    "건배",
    "į sveikatą",
    "Эрүүл мэндийн төлөө",
    "Saúde",
    "Sanatate",
    "živeli",
    "Proscht",
    "Chai yo",
    "Choc tee",
    "Şerefe",
    "будьмо",
    "Budmo",
    "Iechyd da",
    "Sei gesund",
    "за наш", # Russe original. --kienma
    ]

  @bad_drinks %{
    :negative => [
      "on peut pas boire en négatif...",
      "tu crois que ça marche comme ça ? :s",
      "e{{'u' | rrepeat}}h"
    ],
    :null => [
      "tu me prends pas un peu pour un con là ?",
      "zéro ? agis comme un homme et bois une pinte de whisky",
      "gros naze",
      "FATAL ERROR: java.lang.ArithmeticException (cannot divide by zero)",
      "?!?!",
      "votre médecin vous conseille de boire une bouteille de rouge cul sec plutôt"
    ],
    :huge => [
      "tu veux pas aller à l'hopital plutôt ?",
      "tu me prends pas un peu pour un con là ?",
      "ok; j'ai appelé le SAMU, ils arrivent",
      "j'accepterais le !santai quand tu m'auras envoyé la preuve vidéo"
    ],
    :eau => [
      "Le barman, c'est moi ! C'est moi qui suis barman ! Vous êtes la police républicaine ou une bande ? Vous savez qui je suis ? Enfoncez la bouteille, camarades !",
      "L'alcool est notre pire ennemi, fuir est lâche !",
      "attention... l'alcool permet de rendre l'eau potable",
      "{{'QUOI ?' | bold}}",
      "QUO{{'I' | rrepeat}}?",
      "{{\"COMMENT ÇA DE L'EAU ?\" | red}}",
      "resaisis toi et va ouvrir une bonne teille de rouge...",
      "bwais tu veux pas un \"petit\" rhum plutôt ?"
    ]

  }

  def irc_doc, do: @moduledoc

  def start_link(), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)

  # tuple dets: {nick, date, volumes, current_alcohol_level, nom, commentaire}
  # tuple ets:  {{nick, date}, volumes, current, nom, commentaire}
  # tuple meta dets: {nick, map}
  #                   %{:weight => float, :sex => true(h),false(f)}
  @default_user_meta %{weight: 77.4, sex: true, loss_factor: 15}

  def data_state() do
    dets_filename = (LSG.data_path() <> "/" <> "alcoolisme.dets") |> String.to_charlist
    dets_meta_filename = (LSG.data_path() <> "/" <> "alcoolisme_meta.dets") |> String.to_charlist
    %{dets: dets_filename, meta: dets_meta_filename, ets: __MODULE__.ETS}
  end

  def init(_) do
    regopts = [plugin: __MODULE__]
    {:ok, _} = Registry.register(IRC.PubSub, "account", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:santai", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:moar", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:again", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:bis", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:santo", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:santeau", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:alcoolog", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:sobre", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:sobrepour", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:soif", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:alcoolisme", regopts)
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:alcool", regopts)
    dets_filename = (LSG.data_path() <> "/" <> "alcoolisme.dets") |> String.to_charlist
    {:ok, dets} = :dets.open_file(dets_filename, [{:type,:bag}])
    ets = :ets.new(__MODULE__.ETS, [:ordered_set, :named_table, :protected, {:read_concurrency, true}])
    dets_meta_filename = (LSG.data_path() <> "/" <> "alcoolisme_meta.dets") |> String.to_charlist
    {:ok, meta} = :dets.open_file(dets_meta_filename, [{:type,:set}])
    state = %{dets: dets, meta: meta, ets: ets}
    {:ok, state}
  end

  @eau ["santo", "santeau"]
  def handle_info({:irc, :trigger, santeau, m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) when santeau in @eau do
    m.replyfun.(Tmpl.render(Enum.random(Enum.shuffle(Map.get(@bad_drinks, :eau))), m))
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "soif", m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) do
    now = DateTime.utc_now()
          |> Timex.Timezone.convert("Europe/Paris")
    apero = format_duration_from_now(%DateTime{now | hour: 18, minute: 0, second: 0}, false)
    day_of_week = Date.day_of_week(now)
    {txt, apero?} = cond do
      now.hour >= 0 && now.hour < 6 ->
        {["apéro tardif ? Je dis OUI ! SANTAI !"], true}
      now.hour >= 6 && now.hour < 12 ->
        if day_of_week >= 6 do
          {["de l'alcool pour le petit dej ? le week-end, pas de problème !"], true}
        else
          {["C'est quand même un peu tôt non ? Prochain apéro #{apero}"], false}
        end
      now.hour >= 12 && (now.hour < 14) ->
        {["oui! c'est l'apéro de midi! (et apéro #{apero})",
          "tu peux attendre #{apero} ou y aller, il est midi !"
        ], true}
      now.hour == 17 ->
        {[
          "ÇA APPROCHE !!! Apéro #{apero}",
          "BIENTÔT !!! Apéro #{apero}",
          "achetez vite les teilles, apéro dans #{apero}!",
          "préparez les teilles, apéro dans #{apero}!"
        ], false}
      now.hour >= 14 && now.hour < 18 ->
        weekend = if day_of_week >= 6 do
          " ... ou maintenant en fait, c'est le week-end!"
        else
          ""
        end
        {["tiens bon! apéro #{apero}#{weekend}",
          "courage... apéro dans #{apero}#{weekend}",
          "pas encore :'( apéro dans #{apero}#{weekend}"
        ], false}
      true ->
      {[
          "C'EST L'HEURE DE L'APÉRO !!! SANTAIIIIIIIIIIII !!!!"
        ], true}
    end

    txt = txt
          |> Enum.shuffle()
          |> Enum.random()

    m.replyfun.(txt)

    stats = get_full_statistics(state, m.account.id)
    if !apero? && stats.active > 0.1 do
      m.replyfun.("(... ou continue en fait, je suis pas ta mère !)")
    end

    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "sobrepour", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
    args = Enum.join(args, " ")
    {:ok, now} = DateTime.now("Europe/Paris", Tzdata.TimeZoneDatabase)
    time = case args do
      "demain " <> time ->
        {h, m} = case String.split(time, [":", "h"]) do
          [hour, ""] ->
            IO.puts ("h #{inspect hour}")
            {h, _} = Integer.parse(hour)
            {h, 0}
          [hour, min] when min != "" ->
            {h, _} = Integer.parse(hour)
            {m, _} = Integer.parse(min)
            {h, m}
          [hour] ->
            IO.puts ("h #{inspect hour}")
            {h, _} = Integer.parse(hour)
            {h, 0}
          _ -> {0, 0}
        end
        secs = ((60*60)*24)
        day = DateTime.add(now, secs, :second, Tzdata.TimeZoneDatabase)
        %DateTime{day | hour: h, minute: m, second: 0}
      "après demain " <> time ->
        secs = 2*((60*60)*24)
        DateTime.add(now, secs, :second, Tzdata.TimeZoneDatabase)
      datetime ->
        case Timex.Parse.DateTime.Parser.parse(datetime, "{}") do
          {:ok, dt} -> dt
          _ -> nil
        end
    end

    if time do
      meta = get_user_meta(state, m.account.id)
      stats = get_full_statistics(state, m.account.id)

      duration = round(DateTime.diff(time, now)/60.0)

      IO.puts "diff #{inspect duration} sober in #{inspect stats.sober_in}"

      if duration < stats.sober_in do
        int = stats.sober_in - duration
        m.replyfun.("désolé, aucune chance! tu seras sobre #{format_minute_duration(int)} après!")
      else
        remaining = duration - stats.sober_in
        if remaining < 30 do
          m.replyfun.("moins de 30 minutes de sobriété, c'est impossible de boire plus")
        else
          loss_per_minute = ((meta.loss_factor/100)/60)
          remaining_gl = (remaining-30)*loss_per_minute
          m.replyfun.("marge de boisson: #{inspect remaining} minutes, #{remaining_gl} g/l")
        end
      end

    end
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "alcoolog", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :plus}}}, state) do
    {:ok, token} = LSG.Token.new({:alcoolog, :index, m.sender.network, m.channel})
    url = LSGWeb.Router.Helpers.alcoolog_url(LSGWeb.Endpoint, :index, m.network, LSGWeb.format_chan(m.channel), token)
    m.replyfun.("-> #{url}")
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "alcoolog", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :bang}}}, state) do
    url = LSGWeb.Router.Helpers.alcoolog_url(LSGWeb.Endpoint, :index, m.network, LSGWeb.format_chan(m.channel))
    m.replyfun.("-> #{url}")
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "alcool", m = %IRC.Message{trigger: %IRC.Trigger{args: args = [cl, deg], type: :bang}}}, state) do
    {cl, _} = Util.float_paparse(cl)
    {deg, _} = Util.float_paparse(deg)
    points = Alcool.units(cl, deg)
    meta = get_user_meta(state, m.account.id)
    k = if meta.sex, do: 0.7, else: 0.6
    weight = meta.weight
    gl = (10*points)/(k*weight)
    duration = round(gl/((meta.loss_factor/100)/60))+30
        sober_in_s = if duration > 0 do
        duration = Timex.Duration.from_minutes(duration)
          Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized)
        else
          ""
        end

    m.replyfun.("Il y a #{Float.round(points+0.0, 4)} unités d'alcool dans #{cl}cl à #{deg}° (#{Float.round(gl + 0.0, 4)} g/l, #{sober_in_s})")
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: [cl, deg | comment], type: :bang}}}, state) do
    santai(m, state, cl, deg, comment)
    {:noreply, state}
  end

  @moar [
    "{{message.sender.nick}}: la même donc ?",
    "{{message.sender.nick}}: et voilà la petite sœur !"
  ]

  def handle_info({:irc, :trigger, "bis", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
    handle_info({:irc, :trigger, "moar", m}, state)
  end
  def handle_info({:irc, :trigger, "again", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
    handle_info({:irc, :trigger, "moar", m}, state)
  end

  def handle_info({:irc, :trigger, "moar", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
    case get_statistics_for_nick(state, m.account.id) do
      {_, obj = {_, _date, _points, _active, cl, deg, _name, comment, _meta}} ->
        cl = case args do
          [cls] ->
            case Util.float_paparse(cls) do
              {cl, _} -> cl
              _ -> cl
            end
          _ -> cl
        end
        moar = @moar |> Enum.shuffle() |> Enum.random() |> Tmpl.render(m) |> m.replyfun.()
        santai(m, state, cl, deg, comment, auto_set: true)
      {_, obj = {_, date, points, _last_active, type, descr}} ->
        case Regex.named_captures(~r/^(?<cl>\d+[.]\d+)cl\s+(?<deg>\d+[.]\d+)°$/, type) do
          nil -> m.replyfun.("suce")
          u ->
            moar = @moar |> Enum.shuffle() |> Enum.random() |> Tmpl.render(m) |> m.replyfun.()
            santai(m, state, u["cl"], u["deg"], descr, auto_set: true)
        end
      _ -> nil
    end
    {:noreply, state}
  end

  defp santai(m, state, cl, deg, comment, options \\ []) do
    comment = cond do
      comment == [] -> nil
      is_binary(comment) -> comment
      comment == nil -> nil
      true -> Enum.join(comment, " ")
    end

    {cl, cl_extra} = case {Util.float_paparse(cl), cl} do
      {{cl, extra}, _} -> {cl, extra}
    {:error, "("<>_} ->
        try do
          {:ok, result} = Abacus.eval(cl)
          {result, nil}
        rescue
          _ -> {nil, "cl: invalid calc expression"}
        end
      {:error, _} -> {nil, "cl: invalid value"}
    end

    {deg, comment, auto_set, beer_id} = case Util.float_paparse(deg) do
      {deg, _} -> {deg, comment, Keyword.get(options, :auto_set, false), nil}
      :error ->
        beername = if(comment, do: "#{deg} #{comment}", else: deg)
        case Untappd.search_beer(beername, limit: 1) do
          {:ok, %{"response" => %{"beers" => %{"count" => count, "items" => [%{"beer" => beer, "brewery" => brewery} | _]}}}} ->
            {Map.get(beer, "beer_abv"), "#{Map.get(brewery, "brewery_name")}: #{Map.get(beer, "beer_name")}", true, Map.get(beer, "bid")}
          _ ->
              {deg, "could not find beer", false, nil}
        end
    end

    cond do
      cl == nil -> m.replyfun.(cl_extra)
      deg == nil -> m.replyfun.(comment)
      cl >= 500 || deg >= 100 -> m.replyfun.(Tmpl.render(Enum.random(Enum.shuffle(Map.get(@bad_drinks, :huge))), m))
      cl == 0 || deg == 0 -> m.replyfun.(Tmpl.render(Enum.random(Enum.shuffle(Map.get(@bad_drinks, :null))), m))
      cl < 0 || deg < 0 -> m.replyfun.(Tmpl.render(Enum.random(Enum.shuffle(Map.get(@bad_drinks, :negative))), m))
      true ->
        points = Alcool.units(cl, deg)
        now = m.at || DateTime.utc_now()
              |> DateTime.to_unix(:millisecond)
        user_meta = get_user_meta(state, m.account.id)
        name = "#{cl}cl #{deg}°"
        old_stats = get_full_statistics(state, m.account.id)
        meta = %{}
        meta = Map.put(meta, "timestamp", now)
        meta = Map.put(meta, "weight", user_meta.weight)
        meta = Map.put(meta, "sex", user_meta.sex)
        :ok = :dets.insert(state.dets, {m.account.id, now, points, if(old_stats, do: old_stats.active, else: 0), cl, deg, name, comment, meta})
        true = :ets.insert(state.ets, {{m.account.id, now}, points, if(old_stats, do: old_stats.active, else: 0),cl, deg, name, comment, meta})
        sante = @santai |> Enum.map(fn(s) -> String.trim(String.upcase(s)) end) |> Enum.shuffle() |> Enum.random()
        k = if user_meta.sex, do: 0.7, else: 0.6
        weight = user_meta.weight
        peak = Float.round((10*points||0.0)/(k*weight), 4)
        stats = get_full_statistics(state, m.account.id)
        sober_add = if old_stats && Map.get(old_stats || %{}, :sober_in) do
          mins = round(stats.sober_in - old_stats.sober_in)
          " [+#{mins}m]"
        else
          ""
        end
        nonow = DateTime.utc_now()
        sober = nonow |> DateTime.add(round(stats.sober_in*60), :second)
              |> Timex.Timezone.convert("Europe/Paris")
        at = if nonow.day == sober.day do
          {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr")
          detail
        else
          {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr")
          detail
        end

        up = if stats.active_drinks > 1 do
          " " <> Enum.join(for(_ <- 1..stats.active_drinks, do: "▲")) <> ""
        else
          ""
        end

        since_str = if stats.since && stats.since_min > 180 do
        "(depuis: #{stats.since_s}) "
      else
        ""
      end

        msg = fn(nick, extra) ->
          "#{sante} #{nick} #{extra}#{up} #{format_points(points)} @#{stats.active}g/l [+#{peak} g/l]"
          <> " (15m: #{stats.active15m}, 30m: #{stats.active30m}, 1h: #{stats.active1h}) #{since_str}(sobriété #{at} (dans #{stats.sober_in_s})#{sober_add}) !"
          <> " (aujourd'hui #{stats.daily_volumes} points - #{stats.daily_gl} g/l)"
        end

        meta = if beer_id do
          Map.put(meta, "untappd:beer_id", beer_id)
        else
          meta
        end

        if beer_id do
          spawn(fn() ->
            case Untappd.maybe_checkin(m.account, beer_id) do
              {:ok, body} ->
                badges = get_in(body, ["badges", "items"])
                if badges != [] do
                  badges_s = Enum.map(badges, fn(badge) -> Map.get(badge, "badge_name") end)
                           |> Enum.filter(fn(b) -> b end)
                           |> Enum.intersperse(", ")
                           |> Enum.join("")
                    badge = if(length(badges) > 1, do: "badges", else: "badge")
                    m.replyfun.("\\O/ Unlocked untappd #{badge}: #{badges_s}")
                end
                :ok
              {:error, {:http_error, error}} when is_integer(error) -> m.replyfun.("Checkin to Untappd failed: #{to_string(error)}")
              {:error, {:http_error, error}} -> m.replyfun.("Checkin to Untappd failed: #{inspect error}")
              _ -> :error
            end
          end)
        end

        local_extra = if auto_set do
          if comment do
            " #{comment} (#{cl}cl @ #{deg}°)"
          else
            "#{cl}cl @ #{deg}°"
          end
        else
          ""
        end
        m.replyfun.(msg.(m.sender.nick, local_extra))
        notify = IRC.Membership.notify_channels(m.account) -- [{m.network,m.channel}]
        for {net, chan} <- notify do
          user = IRC.UserTrack.find_by_account(net, m.account)
          nick = if(user, do: user.nick, else: m.account.name)
          extra = " " <> present_type(name, comment) <> ""
          IRC.Connection.broadcast_message(net, chan, msg.(nick, extra))
        end

        miss = cond do
          points <= 0.6 -> :blague
          stats.active30m >= 2.9 && stats.active30m < 3 -> :miss3
          stats.active30m >= 1.9 && stats.active30m < 2 -> :miss2
          stats.active30m >= 0.9 && stats.active30m < 1 -> :miss1
          stats.active30m >= 0.45 && stats.active30m < 0.5 -> :miss05
          stats.active30m >= 0.20 && stats.active30m < 0.20 -> :miss025
          stats.active30m >= 3 && stats.active1h < 3.15 -> :small3
          stats.active30m >= 2 && stats.active1h < 2.15 -> :small2
          stats.active30m >= 1.5 && stats.active1h < 1.5 -> :small15
          stats.active30m >= 1 && stats.active1h < 1.15 -> :small1
          stats.active30m >= 0.5 && stats.active1h <= 0.51 -> :small05
          stats.active30m >= 0.25 && stats.active30m <= 0.255 -> :small025
          true -> nil
        end

        miss = case miss do
          :blague -> [
              "c'est une blague ?!"
            ]
          :miss025 -> [
              "si peu ?"
            ]
          :miss05 -> [
              "tu pourras encore conduire, faut boire plus!"
          ]
          :miss1 -> [
              "alerte, tu vas rater le gramme !"
          ]
          :miss2 -> [
              "petit joueur ? rater deux grammes de si peu c'est pas sérieux"
          ]
          :miss3 -> [
              "même pas 3 grammes ? allez ! dernière ligne droite!"
          ]
          :small025 -> [
              "tu vas quand même pas en rester là si ?"
          ]
          :small05 -> [
              "c'est un bon début, faut continuer sur cette lancée !"
            ]
          :small1 -> [
              "un peu plus de motivation sur le gramme et c'est parfait !"
          ]
          :small15 -> [
              "essaie de garder ton gramme et demi plus longtemps !"
          ]
          :small2 -> [
              "même pas une demi heure de deux grammes ? allez, fait un effort !",
              "installe toi mieux aux deux grammes !"
          ]
          :small3 -> [
              "ALLAIIIII CONTINUE FAUT MAINTENIR !",
              "tu vas quand même pas en rester là ?"
          ]
          _ -> nil
        end
        if miss do
          msg = Enum.random(Enum.shuffle(miss))
          for {net, chan} <- IRC.Membership.notify_channels(m.account) do
            user = IRC.UserTrack.find_by_account(net, m.account)
            nick = if(user, do: user.nick, else: m.account.name)
            IRC.Connection.broadcast_message(net, chan, "#{nick}: #{msg}")
          end
        end

    end
  end

  def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: _, type: :bang}}}, state) do
    m.replyfun.("!santai <cl> <degrés> [commentaire]")
    {:noreply, state}
  end

  def get_all_stats() do
    IRC.Account.all_accounts()
    |> Enum.map(fn(account) -> {account.id, get_full_statistics(account.id)} end)
    |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end)
    |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
  end

  def get_channel_statistics(account, network, nil) do
    IRC.Membership.expanded_members_or_friends(account, network, nil)
    |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(account.id)} end)
    |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end)
    |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
  end

  def get_channel_statistics(_, network, channel), do: get_channel_statistics(network, channel)

  def get_channel_statistics(network, channel) do
    IRC.Membership.expanded_members(network, channel)
    |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(account.id)} end)
    |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end)
    |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
  end

  @spec since() :: %{IRC.Account.id() => DateTime.t()}
  @doc "Returns the last time the user was at 0 g/l"
  def since() do
    :ets.foldr(fn({{acct, timestamp}, _vol, current, _cl, _deg, _name, _comment, _m}, acc) ->
      if !Map.get(acc, acct) && current == 0 do
        date = DateTime.from_unix!(timestamp, :millisecond)
        Map.put(acc, acct, date)
      else
        acc
      end
    end, %{}, __MODULE__.ETS)
  end

  def get_full_statistics(nick) do
    get_full_statistics(data_state(), nick)
  end

  defp get_full_statistics(state, nick) do
    case get_statistics_for_nick(state, nick) do
      {count, {_, last_at, last_points, last_active, last_cl, last_deg, last_type, last_descr, _meta}} ->
        {active, active_drinks} = current_alcohol_level(state, nick)
        {_, m30} = alcohol_level_rising(state, nick)
        {rising, m15} = alcohol_level_rising(state, nick, 15)
        {_, m5} = alcohol_level_rising(state, nick, 5)
        {_, h1} = alcohol_level_rising(state, nick, 60)

        trend = if rising do
          "▲"
        else
          "▼"
        end
      user_state = cond do
        active <= 0.0 -> :sober
        active <= 0.25 -> :low
        active <= 0.50 -> :legal
        active <= 1.0 -> :legalhigh
        active <= 2.5 -> :high
        active < 3 -> :toohigh
        true -> :sick
      end
      states = Map.get(@user_states, user_state)
      list = if is_list(states) do
        states
      else
        Map.get(states, rising)
      end
        meta = get_user_meta(state, nick)
        minutes_til_sober = h1/((meta.loss_factor/100)/60)
        minutes_til_sober = cond do
          active < 0 -> 0
          m15 < 0 -> 15
          m30 < 0 -> 30
          h1 < 0 -> 60
          minutes_til_sober > 0 ->
            Float.round(minutes_til_sober+60)
          true -> 0
        end

        duration = Timex.Duration.from_minutes(minutes_til_sober)
        sober_in_s = if minutes_til_sober > 0 do
          Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized)
        else
          nil
        end

        since = if active > 0 do
              since()
              |> Map.get(nick)
        end

        since_diff = if since, do: Timex.diff(DateTime.utc_now(), since, :minutes)
        since_duration = if since, do: Timex.Duration.from_minutes(since_diff)
        since_s = if since, do: Timex.Format.Duration.Formatter.lformat(since_duration, "fr", :humanized)

      user_status = list
                |> Enum.shuffle()
                |> Enum.random()
      {total_volumes, total_gl} = user_stats(state, nick)


        %{active: active, last_at: last_at, last_cl: last_cl, last_deg: last_deg, last_points: last_points, last_type: last_type, last_descr: last_descr,
          trend_symbol: trend,
          active5m: m5, active15m: m15, active30m: m30, active1h: h1,
          rising: rising,
          active_drinks: active_drinks,
          user_status: user_status,
          daily_gl: total_gl, daily_volumes: total_volumes,
          sober_in: minutes_til_sober, sober_in_s: sober_in_s,
          since: since, since_min: since_diff, since_s: since_s,
        }
    _ ->
      nil
    end
  end

  def handle_info({:irc, :trigger, "sobre", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :dot}}}, state) do
    nicks = IRC.Membership.expanded_members_or_friends(m.account, m.network, m.channel)
    |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(state, account.id)} end)
    |> Enum.filter(fn({_nick, status}) -> status && status.sober_in && status.sober_in > 0 end)
    |> Enum.sort_by(fn({_, status}) -> status.sober_in end, &</2)
    |> Enum.map(fn({nick, stats}) ->
      now = DateTime.utc_now()
      sober = now |> DateTime.add(round(stats.sober_in*60), :second)
            |> Timex.Timezone.convert("Europe/Paris")
        at = if now.day == sober.day do
          {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr")
          detail
        else
          {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr")
          detail
        end
      "#{nick} sobre #{at} (dans #{stats.sober_in_s})"
    end)
    |> Enum.intersperse(", ")
    |> Enum.join("")
    |> (fn(line) ->
      case line do
        "" -> "tout le monde est sobre......."
        line -> line
      end
    end).()
    |> m.replyfun.()
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "sobre", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
    account = case args do
      [nick] -> IRC.Account.find_always_by_nick(m.network, m.channel, nick)
      [] -> m.account
    end

    if account do
      user = IRC.UserTrack.find_by_account(m.network, account)
      nick = if(user, do: user.nick, else: account.name)
      stats = get_full_statistics(state, account.id)
      if stats && stats.sober_in > 0 do
        now = DateTime.utc_now()
        sober = now |> DateTime.add(round(stats.sober_in*60), :second)
              |> Timex.Timezone.convert("Europe/Paris")
          at = if now.day == sober.day do
            {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "aujourd'hui {h24}:{m}", "fr")
            detail
          else
            {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(sober, "{WDfull} {h24}:{m}", "fr")
            detail
          end
        m.replyfun.("#{nick} sera sobre #{at} (dans #{stats.sober_in_s})!")
      else
        m.replyfun.("#{nick} est déjà sobre. aidez le !")
      end
    else
      m.replyfun.("inconnu")
    end
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :dot}}}, state) do
    nicks = IRC.Membership.expanded_members_or_friends(m.account, m.network, m.channel)
    |> Enum.map(fn({account, _, nick}) -> {nick, get_full_statistics(state, account.id)} end)
    |> Enum.filter(fn({_nick, status}) -> status && (status.active > 0 || status.active30m > 0) end)
    |> Enum.sort_by(fn({_, status}) -> status.active end, &>/2)
    |> Enum.map(fn({nick, status}) ->
        trend_symbol = if status.active_drinks > 1 do
          Enum.join(for(_ <- 1..status.active_drinks, do: status.trend_symbol))
        else
          status.trend_symbol
        end
      since_str = if status.since_min > 180 do
        "depuis: #{status.since_s} | "
      else
        ""
      end
      "#{nick} #{status.user_status} #{trend_symbol} #{Float.round(status.active, 4)} g/l [#{since_str}sobre dans: #{status.sober_in_s}]"
    end)
    |> Enum.intersperse(", ")
    |> Enum.join("")

    msg = if nicks == "" do
      "wtf?!?! personne n'a bu!"
    else
      nicks
    end

    m.replyfun.(msg)
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [time], type: :dot}}}, state) do
    time = case time do
      "semaine" -> 7
      string ->
        case Integer.parse(string) do
          {time, "j"} -> time
          {time, "J"} -> time
          _ -> nil
        end
    end

    if time do
      aday = time*((24 * 60)*60)
      now = DateTime.utc_now()
      before = now
               |> DateTime.add(-aday, :second)
               |> DateTime.to_unix(:millisecond)
      over_time_stats(before, time, m, state)
    else
      m.replyfun.(".alcooolisme semaine|Xj")
    end
    {:noreply, state}
  end

  def user_over_time(account, count) do
    user_over_time(data_state(), account, count)
  end

  def user_over_time(state, account, count) do
    delay = count*((24 * 60)*60)
    now = DateTime.utc_now()
    before = DateTime.utc_now()
             |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
             |> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase)
             |> DateTime.to_unix(:millisecond)
    #[
#  {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
#   [{:andalso, {:==, :"$1", :"$1"}, {:<, :"$2", {:const, 3000}}}], [:lol]}
    #]
    match = [{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
       [{:andalso, {:>, :"$2", {:const, before}}, {:==, :"$1", {:const, account.id}}}], [:"$_"]}
    ]
    :ets.select(state.ets, match)
    |> Enum.reduce(Map.new, fn({{_, ts}, vol, _, _, _, _, _, _}, acc) ->
      date = DateTime.from_unix!(ts, :millisecond)
             |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)

      date = if date.hour <= 8 do
        DateTime.add(date, -(60*(60*(date.hour+1))), :second, Tzdata.TimeZoneDatabase)
      else
        date
      end
      |> DateTime.to_date()

      Map.put(acc, date, Map.get(acc, date, 0) + vol)
    end)
  end

  def user_over_time_gl(account, count) do
    state = data_state()
    meta = get_user_meta(state, account.id)
    delay = count*((24 * 60)*60)
    now = DateTime.utc_now()
    before = DateTime.utc_now()
             |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
             |> DateTime.add(-delay, :second, Tzdata.TimeZoneDatabase)
             |> DateTime.to_unix(:millisecond)
    #[
#  {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
#   [{:andalso, {:==, :"$1", :"$1"}, {:<, :"$2", {:const, 3000}}}], [:lol]}
    #]
    match = [{{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
       [{:andalso, {:>, :"$2", {:const, before}}, {:==, :"$1", {:const, account.id}}}], [:"$_"]}
    ]
    :ets.select(state.ets, match)
    |> Enum.reduce(Map.new, fn({{_, ts}, vol, _, _, _, _, _, _}, acc) ->
      date = DateTime.from_unix!(ts, :millisecond)
             |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)

      date = if date.hour <= 8 do
        DateTime.add(date, -(60*(60*(date.hour+1))), :second, Tzdata.TimeZoneDatabase)
      else
        date
      end
      |> DateTime.to_date()
      weight = meta.weight
      k = if meta.sex, do: 0.7, else: 0.6
      gl = (10*vol)/(k*weight)

      Map.put(acc, date, Map.get(acc, date, 0) + gl)
    end)
  end



  defp over_time_stats(before, j, m, state) do
    #match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _, _, _, _}) when date > before -> obj end)
    match = [{{{:_, :"$1"}, :_, :_, :_, :_, :_, :_, :_},
       [{:>, :"$1", {:const, before}}], [:"$_"]}
    ]
  # tuple ets:  {{nick, date}, volumes, current, nom, commentaire}
    members = IRC.Membership.members_or_friends(m.account, m.network, m.channel)
    drinks = :ets.select(state.ets, match)
    |> Enum.filter(fn({{account, _}, _, _, _, _, _, _, _}) -> Enum.member?(members, account) end)
             |> Enum.sort_by(fn({{_, ts}, _, _, _, _, _, _, _}) -> ts end, &>/2)

    top = Enum.reduce(drinks, %{}, fn({{nick, _}, vol, _, _, _, _, _, _}, acc) ->
      all = Map.get(acc, nick, 0)
      Map.put(acc, nick, all + vol)
    end)
    |> Enum.sort_by(fn({_nick, count}) -> count end, &>/2)
    |> Enum.map(fn({nick, count}) ->
      account = IRC.Account.get(nick)
      user = IRC.UserTrack.find_by_account(m.network, account)
      nick = if(user, do: user.nick, else: account.name)
      "#{nick}: #{Float.round(count, 4)}"
    end)
    |> Enum.intersperse(", ")

    m.replyfun.("sur #{j} jours: #{top}")
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [], type: :plus}}}, state) do
    meta = get_user_meta(state, m.account.id)
    hf = if meta.sex, do: "h", else: "f"
    m.replyfun.("+alcoolisme sexe: #{hf} poids: #{meta.weight} facteur de perte: #{meta.loss_factor}")
    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: [h, weight | rest], type: :plus}}}, state) do
    h = case h do
      "h" -> true
      "f" -> false
      _ -> nil
    end

      weight = case Util.float_paparse(weight) do
        {weight, _} -> weight
        _ -> nil
      end

      {factor} = case rest do
        [factor] ->
          case Util.float_paparse(factor) do
            {float, _} -> {float}
            _ -> {@default_user_meta.loss_factor}
          end
        _ -> {@default_user_meta.loss_factor}
      end

      if h == nil || weight == nil do
        m.replyfun.("paramètres invalides")
      else
        old_meta = get_user_meta(state, m.account.id)
        meta = Map.merge(@default_user_meta, %{sex: h, weight: weight, loss_factor: factor})
        put_user_meta(state, m.account.id, meta)
        fat = ["t'as grossi...", "bientôt la tonne ?", "t'as encore abusé du fromage ?"]
        thin = ["en route vers l'anorexie ?", "t'as vomi...", "t'as grossi...", "faut manger plus de fromage!"]
        msg = cond do
          old_meta.weight < meta.weight -> Enum.random(Enum.shuffle(fat))
          old_meta.weight == meta.weight -> "ok"
          true -> Enum.random(Enum.shuffle(thin))
        end
        m.replyfun.(msg)
      end

    {:noreply, state}
  end

  def handle_info({:irc, :trigger, "santai", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :minus}}}, state) do
    case get_statistics_for_nick(state, m.account.id) do
      {_, obj = {_, date, points, _last_active, _cl, _deg, type, descr, _meta}} ->
        :dets.delete_object(state.dets, obj)
        :ets.delete(state.ets, {m.account.id, date})
        m.replyfun.("supprimé: #{m.sender.nick} #{points} #{type} #{descr}")
        m.replyfun.("faudrait quand même penser à boire")
        notify = IRC.Membership.notify_channels(m.account) -- [{m.network,m.channel}]
        for {net, chan} <- notify do
          user = IRC.UserTrack.find_by_account(net, m.account)
          nick = if(user, do: user.nick, else: m.account.name)
          IRC.Connection.broadcast_message(net, chan, "#{nick} -santai #{points} #{type} #{descr}")
        end
        {:noreply, state}
      _ ->
        {:noreply, state}
    end
  end


  def handle_info({:irc, :trigger, "alcoolisme", m = %IRC.Message{trigger: %IRC.Trigger{args: args, type: :bang}}}, state) do
    {account, duration} = case args do
      [nick | rest] -> {IRC.Account.find_always_by_nick(m.network, m.channel, nick), rest}
      [] -> {m.account, []}
    end
    if account do
      duration = case duration do
        ["semaine"] -> 7
        [j] ->
          case Integer.parse(j) do
            {j, "j"} -> j
            _ -> nil
          end
        _ -> nil
      end
      user = IRC.UserTrack.find_by_account(m.network, account)
      nick = if(user, do: user.nick, else: account.name)
      if duration do
        if duration > 90 do
          m.replyfun.("trop gros, ça rentrera pas")
        else
          # duration stats
          stats = user_over_time(state, account, duration)
          |> Enum.sort_by(fn({k,_v}) -> k end, {:asc, Date})
          |> Enum.map(fn({date, count}) ->
            "#{date.day}: #{Float.round(count, 2)}"
          end)
          |> Enum.intersperse(", ")
          |> Enum.join("")

          if stats == "" do
            m.replyfun.("alcoolisme a zéro sur #{duration}j :/")
          else
            m.replyfun.("alcoolisme de #{nick}, #{duration} derniers jours: #{stats}")
          end
        end
      else
        if stats = get_full_statistics(state, account.id) do
          trend_symbol = if stats.active_drinks > 1 do
            Enum.join(for(_ <- 1..stats.active_drinks, do: stats.trend_symbol))
          else
            stats.trend_symbol
          end
        # TODO: Lookup nick for account_id
          msg = "#{nick} #{stats.user_status} "
          <> (if stats.active > 0 || stats.active15m > 0 || stats.active30m > 0 || stats.active1h > 0, do: ": #{trend_symbol} #{Float.round(stats.active, 4)}g/l ", else: "")
          <> (if stats.active30m > 0 || stats.active1h > 0, do: "(15m: #{stats.active15m}, 30m: #{stats.active30m}, 1h: #{stats.active1h}) ", else: "")
          <> (if stats.sober_in > 0, do: "— Sobre dans #{stats.sober_in_s} ", else: "")
          <> (if stats.since && stats.since_min > 180, do: "— Paitai depuis #{stats.since_s} ", else: "")
          <> "— Dernier verre: #{present_type(stats.last_type, stats.last_descr)} [#{Float.round(stats.last_points+0.0, 4)}] "
          <> "#{format_duration_from_now(stats.last_at)} "
          <> (if stats.daily_volumes > 0, do: "— Aujourd'hui: #{stats.daily_volumes} #{stats.daily_gl}g/l", else: "")

          m.replyfun.(msg)
        else
          m.replyfun.("honteux mais #{nick} n'a pas l'air alcoolique du tout. /kick")
        end
      end
      else
      m.replyfun.("je ne connais pas cet utilisateur")
    end
    {:noreply, state}
  end


  # Account merge
  def handle_info({:account_change, old_id, new_id}, state) do
    spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [{:==, :"$1", {:const, old_id}}], [:"$_"]}]
    Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) ->
        Logger.debug("alcolog/account_change:: merging #{old_id} -> #{new_id}")
      rename_object_owner(table, state.ets, obj, old_id, new_id)
    end)
    case :dets.lookup(state.meta, {:meta, old_id}) do
      [{_, meta}] ->
        :dets.delete(state.meta, {:meta, old_id})
        :dets.insert(state.meta, {{:meta, new_id}, meta})
      _ ->
        :ok
    end
    {:noreply, state}
  end

  def terminate(_, state) do
    for dets <- [state.dets, state.meta] do
      :dets.sync(dets)
      :dets.close(dets)
    end
  end

  defp rename_object_owner(table, ets, object = {old_id, date, volume, current, cl, deg, name, comment, meta}, old_id, new_id) do
    :dets.delete_object(table, object)
    :ets.delete(ets, {old_id, date})
    :dets.insert(table, {new_id, date, volume, current, cl, deg, name, comment, meta})
    :ets.insert(ets, {{new_id, date}, volume, current, cl, deg, name, comment, meta})
  end

  # Account: move from nick to account id
  def handle_info({:accounts, accounts}, state) do
    #for x={:account, _, _, _, _} <- accounts, do: handle_info(x, state)
    #{:noreply, state}
    mapping = Enum.reduce(accounts, Map.new, fn({:account, _net, _chan, nick, account_id}, acc) ->
      Map.put(acc, String.downcase(nick), account_id)
    end)
    spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [], [:"$_"]}]
      Logger.debug("accounts:: mappings #{inspect mapping}")
    Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj = {nick, _date, _vol, _cur, _cl, _deg, _name, _comment, _meta}) ->
      #Logger.debug("accounts:: item #{inspect(obj)}")
      if new_id = Map.get(mapping, nick) do
        Logger.debug("alcolog/accounts:: merging #{nick} -> #{new_id}")
        rename_object_owner(table, state.ets, obj, nick, new_id)
      end
    end)
    {:noreply, state}
  end

  def handle_info({:account, _net, _chan, nick, account_id}, state) do
    nick = String.downcase(nick)
    spec = [{{:"$1", :_, :_, :_, :_, :_, :_, :_, :_}, [{:==, :"$1", {:const, nick}}], [:"$_"]}]
    Util.ets_mutate_select_each(:dets, state.dets, spec, fn(table, obj) ->
      Logger.debug("alcoolog/account:: merging #{nick} -> #{account_id}")
      rename_object_owner(table, state.ets, obj, nick, account_id)
    end)
    case :dets.lookup(state.meta, {:meta, nick}) do
      [{_, meta}] ->
        :dets.delete(state.meta, {:meta, nick})
        :dets.insert(state.meta, {{:meta, account_id}, meta})
      _ ->
        :ok
    end
    {:noreply, state}
  end

  def handle_info(t, state) do
    Logger.debug("AlcoologPlugin: unhandled info #{inspect t}")
    {:noreply, state}
  end

  def nick_history(account) do
    spec = [
      {{{:"$1", :_}, :_, :_, :_, :_, :_, :_, :_},
      [{:==, :"$1", {:const, account.id}}],
      [:"$_"]}
    ]
    :ets.select(data_state().ets, spec)
  end

  defp get_statistics_for_nick(state, account_id) do
    qvc = :dets.lookup(state.dets, account_id)
          |> Enum.sort_by(fn({_, ts, _, _, _, _, _, _, _}) -> ts end, &</2)
    count = Enum.reduce(qvc, 0, fn({_nick, _ts, points, _active, _cl, _deg, _type, _descr, _meta}, acc) -> acc + (points||0) end)
    last = List.last(qvc) || nil
    {count, last}
  end

  def present_type(type, descr) when descr in [nil, ""], do: "#{type}"
  def present_type(type, description), do: "#{type} (#{description})"

  def format_points(int) when is_integer(int) and int > 0 do
    "+#{Integer.to_string(int)}"
  end
  def format_points(int) when is_integer(int) and int < 0 do
    Integer.to_string(int)
  end
  def format_points(int) when is_float(int) and int > 0 do
    "+#{Float.to_string(Float.round(int,4))}"
  end
  def format_points(int) when is_float(int) and int < 0 do
    Float.to_string(Float.round(int,4))
  end
  def format_points(0), do: "0"
  def format_points(0.0), do: "0"

  defp format_relative_timestamp(timestamp) do
    alias Timex.Format.DateTime.Formatters
    alias Timex.Timezone
    date = timestamp
    |> DateTime.from_unix!(:millisecond)
    |> Timezone.convert("Europe/Paris")

    {:ok, relative} = Formatters.Relative.relative_to(date, Timex.now("Europe/Paris"), "{relative}", "fr")
    {:ok, detail} = Formatters.Default.lformat(date, " ({h24}:{m})", "fr")

    relative <> detail
  end

  defp put_user_meta(state, account_id, meta) do
    :dets.insert(state.meta, {{:meta, account_id}, meta})
    :ok
  end

  defp get_user_meta(%{meta: meta}, account_id) do
    case :dets.lookup(meta, {:meta, account_id}) do
      [{{:meta, _}, meta}] ->
        Map.merge(@default_user_meta, meta)
      _ ->
        @default_user_meta
    end
  end
  # Calcul g/l actuel:
  # 1. load user meta
  # 2. foldr ets
  #   for each object
  #     get_current_alcohol
  #         ((object g/l) - 0,15/l/60)* minutes_since_drink
  #         if minutes_since_drink < 10, reduce g/l (?!)
  #     acc + current_alcohol
  #   stop folding when ?
  #

  def user_stats(account) do
    user_stats(data_state(), account.id)
  end

  defp user_stats(state = %{ets: ets}, account_id) do
    meta = get_user_meta(state, account_id)
    aday = (10 * 60)*60
    now = DateTime.utc_now()
    before = now
    |> DateTime.add(-aday, :second)
    |> DateTime.to_unix(:millisecond)
    #match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _}) when date > before -> obj end)
    match = [
      {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
       [
         {:>, :"$2", {:const, before}},
         {:"=:=", {:const, account_id}, :"$1"}
       ], [:"$_"]}
    ]
  # tuple ets:  {{nick, date}, volumes, current, nom, commentaire}
    drinks = :ets.select(ets, match)
    # {date, single_peak}
    total_volume = Enum.reduce(drinks, 0.0, fn({{_, date}, volume, _, _, _, _, _, _}, acc) ->
      acc + volume
    end)
    k = if meta.sex, do: 0.7, else: 0.6
    weight = meta.weight
    gl = (10*total_volume)/(k*weight)
    {Float.round(total_volume + 0.0, 4), Float.round(gl + 0.0, 4)}
  end

  defp alcohol_level_rising(state, account_id, minutes \\ 30) do
    {now, _} = current_alcohol_level(state, account_id)
    soon_date = DateTime.utc_now
                |> DateTime.add(minutes*60, :second)
    {soon, _} = current_alcohol_level(state, account_id, soon_date)
    soon = cond do
      soon < 0 -> 0.0
      true -> soon
    end
    #IO.puts "soon #{soon_date} - #{inspect soon} #{inspect now}"
    {soon > now, Float.round(soon+0.0, 4)}
  end

  defp current_alcohol_level(state = %{ets: ets}, account_id, now \\ nil) do
    meta = get_user_meta(state, account_id)
    aday = ((24*7) * 60)*60
    now = if now do
      now
    else
      DateTime.utc_now()
    end
    before = now
    |> DateTime.add(-aday, :second)
    |> DateTime.to_unix(:millisecond)
    #match = :ets.fun2ms(fn(obj = {{^nick, date}, _, _, _, _}) when date > before -> obj end)
    match = [
      {{{:"$1", :"$2"}, :_, :_, :_, :_, :_, :_, :_},
       [
         {:>, :"$2", {:const, before}},
         {:"=:=", {:const, account_id}, :"$1"}
       ], [:"$_"]}
    ]
  # tuple ets:  {{nick, date}, volumes, current, nom, commentaire}
    drinks = :ets.select(ets, match)
             |> Enum.sort_by(fn({{_, date}, _, _, _, _, _, _, _}) -> date end, &</2)
    # {date, single_peak}
    {all, last_drink_at, gl, active_drinks} = Enum.reduce(drinks, {0.0, nil, [], 0}, fn({{_, date}, volume, _, _, _, _, _, _}, {all, last_at, acc, active_drinks}) ->
      k = if meta.sex, do: 0.7, else: 0.6
      weight = meta.weight
      peak = (10*volume)/(k*weight)
      date = DateTime.from_unix!(date, :millisecond)
      last_at = last_at || date
      mins_since = round(DateTime.diff(now, date)/60.0)
      #IO.puts "Drink: #{inspect({date, volume})} - mins since: #{inspect mins_since} - last drink at #{inspect last_at}"
      # Apply loss since `last_at` on `all`
      #
      all = if last_at do
        mins_since_last = round(DateTime.diff(date, last_at)/60.0)
        loss = ((meta.loss_factor/100)/60)*(mins_since_last)
        #IO.puts "Applying last drink loss: from #{all}, loss of #{inspect loss} (mins since #{inspect mins_since_first})"
        cond do
          (all-loss) > 0 -> all - loss
          true -> 0.0
        end
      else
        all
      end
            #IO.puts "Applying last drink current before drink: #{inspect all}"
      if mins_since < 30 do
        per_min = (peak)/30.0
        current = (per_min*mins_since)
          #IO.puts "Applying current drink 30m: from #{peak}, loss of #{inspect per_min}/min (mins since #{inspect mins_since})"
        {all + current, date, [{date, current} | acc], active_drinks + 1}
      else
        {all + peak, date, [{date, peak} | acc], active_drinks}
      end
    end)
    #IO.puts "last drink #{inspect last_drink_at}"
    mins_since_last = if last_drink_at do
      round(DateTime.diff(now, last_drink_at)/60.0)
    else
      0
    end
    # Si on a déjà bu y'a déjà moins 15 minutes (big up le binge drinking), on applique plus de perte
    level = if mins_since_last > 15 do
      loss = ((meta.loss_factor/100)/60)*(mins_since_last)
      Float.round(all - loss, 4)
    else
      all
    end
    #IO.puts "\n LEVEL #{inspect level}\n\n\n\n"
    cond do
      level < 0 -> {0.0, 0}
      true -> {level, active_drinks}
    end
  end

  defp format_duration_from_now(date, with_detail \\ true) do
    date = if is_integer(date) do
      date = DateTime.from_unix!(date, :millisecond)
      |> Timex.Timezone.convert("Europe/Paris")
    else
      date
    end
    now = DateTime.utc_now()
    |> Timex.Timezone.convert("Europe/Paris")
    {:ok, detail} = Timex.Format.DateTime.Formatters.Default.lformat(date, "({h24}:{m})", "fr")
    mins_since = round(DateTime.diff(now, date)/60.0)
    if ago = format_minute_duration(mins_since) do
      word = if mins_since > 0 do
        "il y a "
      else
        "dans "
      end
      word <> ago <> if(with_detail, do: " #{detail}", else: "")
    else
      "maintenant #{detail}"
    end
  end

  defp format_minute_duration(minutes) do
    sober_in_s = if (minutes != 0) do
      duration = Timex.Duration.from_minutes(minutes)
      Timex.Format.Duration.Formatter.lformat(duration, "fr", :humanized)
    else
      nil
    end
  end

end