# https://github.com/memcached/old-wiki/blob/master/MemcacheBinaryProtocol.wiki
defmodule Memcache.Protocol do
  @moduledoc false

  import Memcache.BinaryUtils
  alias Memcache.BinaryUtils.Header

  def to_binary(:QUIT, opaque) do
    [
      bcat([ request, opb(:QUIT), << 0x00 :: size(16) >>,
             << 0x00 >>, datatype, reserved,
             << 0x00 :: size(32) >> ]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>
    ]
  end

  def to_binary(:QUITQ, opaque) do
    [
      bcat([ request, opb(:QUITQ), << 0x00 :: size(16) >>,
             << 0x00 >>, datatype, reserved,
             << 0x00 :: size(32) >> ]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>
    ]
  end

  def to_binary(:NOOP, opaque) do
    [
      bcat([ request, opb(:NOOP), << 0x00 :: size(16) >>,
             << 0x00 >>, datatype, reserved,
             << 0x00 :: size(32) >> ]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>
    ]
  end

  def to_binary(:VERSION, opaque) do
    [
      bcat([ request, opb(:VERSION), << 0x00 :: size(16) >>,
             << 0x00 >>, datatype, reserved,
             << 0x00 :: size(32) >> ]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>
    ]
  end

  def to_binary(:STAT, opaque) do
    [
      bcat([ request, opb(:STAT), << 0x00 :: size(16) >>,
             << 0x00 >>, datatype, reserved,
             << 0x00 :: size(32) >> ]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>
    ]
  end

  def to_binary(:AUTH_LIST, opaque) do
    [
      bcat([ request, opb(:AUTH_LIST), << 0x00 :: size(16) >>,
             << 0x00 >>, datatype, reserved,
             << 0x00 :: size(32) >> ]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>
    ]
  end

  def to_binary(command, opaque) do
    to_binary(command, opaque, 0)
  end

  def to_binary(:STAT, opaque, key) do
    [
      bcat([ request, opb(:STAT)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      key
    ]
  end

  def to_binary(:GET, opaque, key) do
    [
      bcat([ request, opb(:GET)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      key
    ]
  end

  def to_binary(:GETQ, opaque, key) do
    [
      bcat([ request, opb(:GETQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      key
    ]
  end

  def to_binary(:GETK, opaque, key) do
    [
      bcat([ request, opb(:GETK)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      key
    ]
  end

  def to_binary(:GETKQ, opaque, key) do
    [
      bcat([ request, opb(:GETKQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      key
    ]
  end

  def to_binary(:FLUSH, opaque, expiry) do
    [
      bcat([ request, opb(:FLUSH), << 0x00 :: size(16) >>,
             << 0x04 >>, datatype, reserved,
             << 0x04 :: size(32) >>]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      << expiry :: size(32) >>
    ]
  end

  def to_binary(:FLUSHQ, opaque, expiry) do
    [
      bcat([ request, opb(:FLUSHQ), << 0x00 :: size(16) >>,
             << 0x04 >>, datatype, reserved,
             << 0x04 :: size(32) >>]),
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      << expiry :: size(32) >>
    ]
  end


  def to_binary(:AUTH_START, opaque, key) do
    [
      bcat([ request, opb(:AUTH_START)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      key
    ]
  end

  def to_binary(command, opaque, key) do
    to_binary(command, opaque, key, 0)
  end

  def to_binary(:AUTH_START, opaque, key, value) do
    [
      bcat([ request, opb(:AUTH_START)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << 0x00 :: size(64) >>,
      key,
      value
    ]
  end

  def to_binary(:DELETE, opaque, key, cas) do
    [
      bcat([ request, opb(:DELETE)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >> ,
      key
    ]
  end

  def to_binary(:DELETEQ, opaque, key, cas) do
    [
      bcat([ request, opb(:DELETEQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      key
    ]
  end

  def to_binary(command, opaque, key, value) do
    to_binary(command, opaque, key, value, 0)
  end

  def to_binary(:APPEND, opaque, key, value, cas) do
    [
      bcat([ request, opb(:APPEND)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      key,
      value
    ]
  end

  def to_binary(:APPENDQ, opaque, key, value, cas) do
    [
      bcat([ request, opb(:APPENDQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      key,
      value
    ]
  end

  def to_binary(:PREPEND, opaque, key, value, cas) do
    [
      bcat([ request, opb(:PREPEND)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      key,
      value
    ]
  end

  def to_binary(:PREPENDQ, opaque, key, value, cas) do
    [
      bcat([ request, opb(:PREPENDQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x00 >>, datatype, reserved]),
      << byte_size(key) + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      key,
      value
    ]
  end

  def to_binary(command, opaque, key, value, cas) do
    to_binary(command, opaque, key, value, cas, 0)
  end


  def to_binary(command, opaque, key, value, cas, flag) do
    to_binary(command, opaque, key, value, cas, flag, 0)
  end

  def to_binary(:INCREMENT, opaque, key, delta, initial, cas, expiry) do
    [
      bcat([ request, opb(:INCREMENT)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x14 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 20 :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << delta :: size(64) >>,
      << initial :: size(64) >>,
      << expiry :: size(32) >>,
      key
    ]
  end

  def to_binary(:INCREMENTQ, opaque, key, delta, initial, cas, expiry) do
    [
      bcat([ request, opb(:INCREMENTQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x14 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 20 :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << delta :: size(64) >>,
      << initial :: size(64) >>,
      << expiry :: size(32) >>,
      key
    ]
  end

  def to_binary(:DECREMENT, opaque, key, delta, initial, cas, expiry) do
    [
      bcat([ request, opb(:DECREMENT)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x14 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 20 :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << delta :: size(64) >>,
      << initial :: size(64) >>,
      << expiry :: size(32) >>,
      key
    ]
  end

  def to_binary(:DECREMENTQ, opaque, key, delta, initial, cas, expiry) do
    [
      bcat([ request, opb(:DECREMENTQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x14 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 20 :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << delta :: size(64) >>,
      << initial :: size(64) >>,
      << expiry :: size(32) >>,
      key
    ]
  end

  def to_binary(:SET, opaque, key, value, cas, expiry, flag) do
    [
      bcat([ request, opb(:SET)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x08 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 8 + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << flag :: size(32) >>,
      << expiry :: size(32) >>,
      key,
      value
    ]
  end

  def to_binary(:SETQ, opaque, key, value, cas, expiry, flag) do
    [
      bcat([ request, opb(:SETQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x08 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 8 + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << flag :: size(32) >>,
      << expiry :: size(32) >>,
      key,
      value
    ]
  end

  def to_binary(:ADD, opaque, key, value, expiry, cas, flag) do
    [
      bcat([ request, opb(:ADD)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x08 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 8 + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << flag :: size(32) >>,
      << expiry :: size(32) >>,
      key,
      value
    ]
  end

  def to_binary(:ADDQ, opaque, key, value, cas, expiry, flag) do
    [
      bcat([ request, opb(:ADDQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x08 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 8 + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << flag :: size(32) >>,
      << expiry :: size(32) >>,
      key,
      value
    ]
  end

  def to_binary(:REPLACE, opaque, key, value, cas, expiry, flag) do
    [
      bcat([ request, opb(:REPLACE)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x08 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 8 + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << flag :: size(32) >>,
      << expiry :: size(32) >>,
      key,
      value
    ]
  end

  def to_binary(:REPLACEQ, opaque, key, value, cas, expiry, flag) do
    [
      bcat([ request, opb(:REPLACEQ)]),
      << byte_size(key) :: size(16) >>,
      bcat([<< 0x08 >>, << 0x00 >>, << 0x0000 :: size(16) >>]),
      << byte_size(key) + 8 + IO.iodata_length(value) :: size(32) >>,
      << opaque :: size(32) >>,
      << cas :: size(64) >>,
      << flag :: size(32) >>,
      << expiry :: size(32) >>,
      key,
      value
    ]
  end

  def parse_header(<<
                   0x81 :: size(8),
                   opcode :: size(8),
                   key_length :: size(16),
                   extra_length :: size(8),
                   data_type :: size(8),
                   status :: size(16),
                   total_body_length :: size(32),
                   opaque :: size(32),
                   cas :: size(64)
                   >>) do
    %Header{ opcode: opcode, key_length: key_length, extra_length: extra_length, data_type: data_type, status: status, total_body_length: total_body_length, opaque: opaque, cas: cas }
  end

  def total_body_size(%Header{total_body_length: size}) do
    size
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:GET), extra_length: extra_length, total_body_length: total_body_length, opaque: opaque }, rest) do
    value_size = (total_body_length - extra_length)
    << _extra :: binary-size(extra_length),  value :: binary-size(value_size) >> = rest
    { opaque, { :ok, value } }
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:GETQ), extra_length: extra_length, total_body_length: total_body_length, opaque: opaque }, rest) do
    value_size = (total_body_length - extra_length)
    << _extra :: binary-size(extra_length),  value :: binary-size(value_size) >> = rest
    { opaque, { :ok, value } }
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:GETK), extra_length: extra_length, key_length: key_length, total_body_length: total_body_length, opaque: opaque }, rest) do
    value_size = (total_body_length - extra_length - key_length)
    << _extra :: binary-size(extra_length), key :: binary-size(key_length), value :: binary-size(value_size) >> = rest
    { opaque, { :ok, key, value } }
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:GETKQ), extra_length: extra_length, key_length: key_length, total_body_length: total_body_length, opaque: opaque }, rest) do
    value_size = (total_body_length - extra_length - key_length)
    << _extra :: binary-size(extra_length), key :: binary-size(key_length), value :: binary-size(value_size) >> = rest
    { opaque, { :ok, key, value }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:VERSION), opaque: opaque }, rest) do
    { opaque, { :ok, rest } }
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:AUTH_LIST), opaque: opaque }, rest) do
    { opaque, { :ok, rest }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:INCREMENT), opaque: opaque}, rest) do
    << value :: size(64) >> = rest
    { opaque, { :ok, value }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:INCREMENTQ), opaque: opaque }, rest) do
    << value :: size(64) >> = rest
    { opaque, { :ok, value }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:DECREMENT), opaque: opaque }, rest) do
    << value :: size(64) >> = rest
    { opaque, { :ok, value }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:DECREMENTQ), opaque: opaque }, rest) do
    << value :: size(64) >> = rest
    { opaque, { :ok, value }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:AUTH_START), opaque: opaque}, _rest) do
    { opaque, { :ok }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:STAT), key_length: 0, total_body_length: 0, opaque: opaque }, _rest) do
    { opaque, { :ok, :done }}
  end

  def parse_body(%Header{ status: 0x0000, opcode: op(:STAT), key_length: key_length, total_body_length: total_body_length, opaque: opaque }, rest) do
    value_size = (total_body_length - key_length)
    << key :: binary-size(key_length),  value :: binary-size(value_size) >> = rest
    { opaque, { :ok, key, value } }
  end

  def parse_body(%Header{ status: 0x0021, opaque: opaque }, body) do
    { opaque, { :error, :auth_step, body } }
  end

  defparse_empty(:SET)
  defparse_empty(:ADD)
  defparse_empty(:REPLACE)
  defparse_empty(:DELETE)
  defparse_empty(:QUIT)
  defparse_empty(:FLUSH)
  defparse_empty(:NOOP)
  defparse_empty(:APPEND)
  defparse_empty(:PREPEND)

  defparse_error(0x0001, "Key not found")
  defparse_error(0x0002, "Key exists")
  defparse_error(0x0003, "Value too large")
  defparse_error(0x0004, "Invalid arguments")
  defparse_error(0x0005, "Item not stored")
  defparse_error(0x0006, "Incr/Decr on non-numeric value")
  defparse_error(0x0008, "Authentication Error")
  defparse_error(0x0009, "Authentication Continue")
  defparse_error(0x0020, "Authentication required / Not Successful")
  defparse_error(0x0081, "Unknown command")
  defparse_error(0x0082, "Out of memory")

  def quiet_response(:GETQ), do: { :error, "Key not found" }
  def quiet_response(:GETKQ), do: { :error, "Key not found" }
  def quiet_response(:SETQ), do: { :ok }
  def quiet_response(:ADDQ), do: { :ok }
  def quiet_response(:DELETEQ), do: { :ok }
  def quiet_response(:REPLACEQ), do: { :ok }
  def quiet_response(:INCREMENTQ), do: { :ok }
  def quiet_response(:DECREMENTQ), do: { :ok }
  def quiet_response(:APPENDQ), do: { :ok }
  def quiet_response(:PREPENDQ), do: { :ok }
  def quiet_response(:FLUSHQ), do: { :ok }
  def quiet_response(:QUITQ), do: { :ok }

end