apollo18

defmodule Apollo18.Cipher do

  @moduledoc """
  Provides cipher mechanism to make your things be like Apollo 18: 
  Officially don't exists, only the owner know that it (if ?) exists.
  
  The truth is out there (Maybe ...).
  """

  alias Krug.StringUtil
  alias Krug.NumberUtil
  alias Krug.SanitizerUtil
  alias Krug.EtsUtil
  alias Apollo18.B
  
  @z B.e()
  @b B.d()
  @a 4294967296

  
  
  @doc """
  Cipher a text/string object. Each time that a same string
  is ciphered, the cipher will be another cipher.
  However when decipher all then will result in same 
  origin string.
  
  The ```salt``` parameter can be used to make more strong the cipher.
  Increase of processing time is also proportional to this value.
  By default the minimum value is equal to 1.
  
  Only supported chars will be ciphered. All non supported chars
  will be removed from original text/string before of
  cipher process. This could generate some decipher "issues".
  
  Supported chars
  ```elixir
    [
      "A","Ä","Ã","Â","Á","À","Æ","А",
      "B","Б","Ъ","Ь","Ы","C","Ç","D","Ð","Д","В","С",
      "E","Ë","Ẽ","Ê","É","È","Э","Е",
      "F","Ф","G","Г","H","Н",
      "I","Ï","Ĩ","Î","Í","Ì",
      "J","Ж","K","К","L","Л",
      "M","М","N","Ñ","И","Й",
      "O","Ö","Õ","Ô","Ó","Ò","Ѳ","О",
      "P","Р","П","Q","R","S","Ш","Щ","T","Т","Þ","Ц","Ч",
      "U","Ü","Ũ","Û","Ú","Ù",
      "V","X","Х","W",
      "Y","Ÿ","Ỹ","Ŷ","Ý","Ỳ","У",
      "Z","З",
      "ẞ","Ю","Я",
      "a","ä","ã","â","á","à","æ","а",
      "b","б","ъ","ь","ы","c","ç","d","ð","д","в","с",
      "e","ë","ẽ","ê","é","è","ə","œ","ɛ","э","е",
      "f","ф","g","г","h","н",
      "i","ï","ĩ","î","í","ì",
      "j","ж","k","к","l","л",
      "m","м","n","ñ","и","й",
      "o","ö","õ","ô","ó","ò","ѳ","о",
      "p","р","п","q","r","s","ш","щ","t","т","þ","ц","ч",
      "u","ü","ũ","û","ú","ù",
      "v","x","х","w",
      "y","ÿ","ỹ","ŷ","ý","ỳ","у",
      "z","з",
      "ß","ю","я",
      "ʃ","ʒ","ʁ","ɾ",
      "Ѣ","ѣ","Ѵ","ѵ",
      "0","1","2","3","4","5","6","7","8","9",
      " ",".",",",";",":","<",">","/","\\","?","|",
      "[","]","{","}","(",")","º","°","ª",
      "+","-","=","_","*","&","%","$","#","@",
      "~","^","´","`","‘","’","“","”",
      "!","'","\"","\\n","\\r","\\t","\\b","\\f"
    ]
  ```
  
  ## Examples
    
  ```elixir
  iex > Apollo18.Cipher.cipher("mytext")
  "789C4111413031FF412031DFD115D167D176D143D137D176"
  ```
  ```elixir
  iex > Apollo18.Cipher.cipher("mytext")
  "FFD8FFEE4129414031DF31DF31FF021402660275024202360275"
  ```
  ```elixir
  iex > Apollo18.Cipher.cipher("mytext")
  "1F8B411131EF4110415031CFA0EAA03DA04CA019A00DA04C"
  ```
  ```elixir
  iex > Apollo18.Cipher.cipher("mytext",2)
  "CAFEBABE41594120410041004100918F9193918F918491CF91DF91B
  F91B391BF9193917F915F919F916F916F916F919F916F919F915F919
  F916F915F915F918F916F91939184919F916F91AF915F916F917F91E
  F91BF916F917F910491DF916F917F918491CF916F917F9193919F916
  F917F914391DF916F917F918491CF"
  ```
  ```elixir
  iex > Apollo18.Cipher.cipher("mytext",3)
  "504B0506313F4130413031DF4150E143E172E134E1B3E1F2E172E1F2
  E1B3E14FE11FE10FE11FE14FE11FE14FE10FE13FE11FE163E134E14FE
  11FE10FE10FE14FE11FE11FE10FE10FE12FE11FE172E10FE12FE11FE1
  72E10FE12FE1B3E19FE134E11FE163E1B3E10FE12FE1B3E19FE10FE12
  FE10FE172E10FE12FE1B3E19FE10FE12FE10FE172E10FE12FE163E19F
  E10FE12FE1F2E19FE134E11FE1B3E163E134E11FE163E1B3E10FE12FE
  1B3E19FE10FE12FE1F2E19FE10FE12FE172E19FE10FE12FE172E19FE1
  0FE12FE163E19FE10FE12FE1F2E19FE134E11FE163E1B3E134E11FE16
  3E1B3E10FE12FE163E19FE10FE12FE1F2E19FE134E11FE10FE1B3E134
  E11FE163E1B3E10FE12FE143E19FE10FE12FE172E19FE134E11FE163E
  1B3E10FE12FE163E19FE10FE12FE143E19FE10FE12FE172E19FE10FE1
  2FE1B3E19FE10FE12FE10FE172E10FE12FE143E19FE10FE12FE172E19
  FE10FE12FE134E19FE10FE12FE134E19FE10FE12FE143E19FE10FE12F
  E172E19FE10FE12FE143E19FE10FE12FE143E19FE10FE12FE143E19FE
  10FE12FE172E19FE10FE12FE1F2E19FE10FE12FE10FE172E10FE12FE1
  43E19FE10FE12FE172E19FE10FE12FE134E19FE10FE12FE134E19F"
  ```
  """
  def cipher(string,salt \\ 1,key \\ 0) do
    b = m()
    EtsUtil.new(b)
    k = j(string,salt |> f(),key,b,0)
    EtsUtil.delete(b)
    k
  end
  
  
  
  @doc """
  Decipher a previously ciphered string that contains a text/string object.
  
  Should be used the same ```salt``` and ```key``` values used in call to cipher function.
  
  ## Examples
    
  ```elixir
  iex > Apollo18.Cipher.decipher("78DA313F41504100413031EF5209525B526A5237522B526A")
  "mytext"
  ```
  ```elixir
  iex > Apollo18.Cipher.decipher("00000100313F4130415041304120F18BF1DDF1ECF1B9F1ADF1EC")
  "mytext"
  ```
  ```elixir
  iex > Apollo18.Cipher.decipher("D0CF11E0A1B11AE14129415031FF31FF4100526052B252C1429E528252C1")
  "mytext"
  ```
  """
  def decipher(string,salt \\ 1,key \\ 0) do
    z = dm()
    EtsUtil.new(z)
    j = w(string,salt |> f(),key,z,0)
    EtsUtil.delete(z)
    j
  end



  defp p(f,e,h,z,a,x,p,t) do
    cond do
      (z >= a) -> e |> i()
      true -> y(f,e,h,z,a,x,p,t)
    end
  end


  
  defp y(q,p,x,o,a,u,e,k) do
    h = q |> hd()
    cond do
      (!(x |> y(h))) -> p(q |> tl(),p,x,o + 1,a,u,e,k)
      true -> p(q |> tl(),[m(x,h,u,e,k) | p],x,o + 1,a,u,e,k)
    end
  end


  
  defp m(z,c,b,t,a) do
    i = n(t,"",c,b,a)
    cond do
      (nil != i) -> i
      true -> v(z,c,b,t,a) 
    end
  end
  
  
  
  defp v(w,k,x,e,t) do
    y = (x + v(w,k,0)) |> t() |> n(4) |> m() |> z() |> u()
    n("",e,k,x,t,y)
  end
  
  
  
  defp n(w,x,m,r,e,d) do
    EtsUtil.store_in_cache(x,e(w,m,r,e),d)
    d
  end


  
  defp v(g,f,y) do
    cond do
      (m(g,y) == f) -> y
      true -> v(g,f,y + 1)
    end
  end


  
  defp i(i,z,n \\ 0) do
    cond do
      (n >= s(i)) -> z
      (z |> e(m(i,n))) -> s(z,m(i,n))
      true -> i(i,z,n + 1)
    end
  end
  


  defp w(k) do
    "#{m(k,1)}#{m(k,0)}#{m(k,3)}#{m(k,2)}" 
  end
  
  
  
  defp s(b,a) do
    x = a |> q()
    z = b |> q()
    b |> p(x,z)
  end
  

  
  defp x(j,l,k,s,v,a \\ []) do
    cond do
      (nil == j or s(j) == 0) -> a |> i() |> j("")
      (j |> hd() |> e() == "") -> x(j |> tl(),l,k,s,v,a)
      true -> x(j |> tl(),l,k,s,v,[l(j |> hd(),l,k,s,v) | a])
    end
  end
  
  
  
  defp y(z) do
    cond do
      (!z) -> 20
      true -> 52
    end
  end
  
  
  
  defp w(w,p,n,k,o) do
    cond do
      (o >= p) -> w
      true -> h(w,n,k,o == (p - 1)) |> w(p,n,k,o + 1)
    end
  end
  
  
  
  defp n(t,w,c,p,x) do
    EtsUtil.read_from_cache(t,e(w,c,p,x))
  end
  
  
  
  defp dm(p) do
    p |> NumberUtil.to_positive()
  end
  
  
  
  defp h(u,n,i,t) do
    r = r(10)
    u = i(@b,u)
    h = p(u,0,19)
    a = p(h,0,1)
    b = p(h,18,19)
    h = p(h,2,17)
    l = p(h,0,3) |> g()
    z = p(h,4,7) |> g()
    p = p(h,8,11) |> g()
    e = p(h,12,15) |> g()
    m = p(l,z,p,e)
    d = p(u,y(t),q(u))
    x(a,b,n,i,r,t,u,d,m)
  end
  
  
  
  defp n(f) do
    f |> Integer.parse(16)
  end
  
  
  
  defp p(r,j,f) do
    r |> String.slice(j..f)
  end



  defp l(c,b,f,a,g) do
    z = n(a,"de",c,f,g)
    cond do
      (nil == z or z == "") -> t(c,b,f,a,g) 
      true -> z
    end
  end
  
  
  
  defp j(k,l,e,z,h) do
    cond do
      (h >= l) -> k
      true -> f(k,e,z,h == 0) |> j(l,e,z,h + 1)
    end
  end



  defp e(t,z,x,y) do
    "#{t}ciphered_#{z}_#{x}_#{y}"
  end


  
  defp t(t,z,r,k,w) do
    q = (g(t) - r) |> dm()
    u = m(z,q)
    n("de",k,t,r,w,u)
  end
  
  
  
  defp n(m,n) do
    m |> StringUtil.left_zeros(n)
  end


  
  defp g(y) do
    y |> m() |> w() |> n() |> p() |> m(0)
  end
  
  
  
  defp u(i) do
    i |> IO.iodata_to_binary()
  end
  
  
  
  defp m(r,s) do
    r |> Enum.at(s)
  end
  
  
  
  defp x(a,b,s,r,y,o,n,d,m) do
    c = "#{a}#{b}" |> n() |> p() |> m(0) |> B.a()
    b = s |> d(c,0,r,y)
    cond do
      (o and b != (n |> c())) -> x("",b)
      true -> x(d |> o(),c,m,r,y)
    end
  end
  
  
  
  defp e(r,u) do
    r |> String.starts_with?(u)
  end
  
  
  
  defp q(v) do
    v |> String.length()
  end
  
    
  
  defp b(a) do
    cond do
      (nil == a or !(a > 0)) -> 0
      true -> rem(a,@a)
    end
  end
  
  
  
  defp o(n) do
    n |> c(4)
  end
  
  
  
  defp d(x) do
    x |> String.to_atom()
  end
  
  
  
  defp r(w) do
    SanitizerUtil.generate_random_only_num(w)
  end
  
  
  
  defp c(a) do
    a |> p(20,51) |> c(4) |> j("")
  end
  
  
  
  defp t(u) do
    u |> Integer.to_string(16)
  end
  
  
  
  defp f(u,k,e,o) do
    r = r(10)
    a = B.z()
    z = B.a(a)
    a = a |> t() |> n(4)
    h = u |> m()
    m = B.b()
    x = m |> n(4) |> m() |> p([],w(),0,4,@z,e,r) |> u()
    k = p(o,k,z,e,r)
    y = e(h,z,h |> s(),m,e,r)
    "#{a |> p(0,1)}#{x}#{a |> p(2,3)}" |> m(k,y)
  end
  
  
  
  defp i(k) do
    k |> Enum.reverse()
  end
  
  
  
  defp m() do
    x = "ollo1"
    z = "_ciph"
    z = "ap#{x}8#{z}er_"
    x = 30
    "#{z}#{r(x)}" |> d()
  end
  
  
  
  defp s(h) do
    h |> length()
  end
  
  
  
  defp d(u,t,n,r,v) do
    p = []
    z = 8
    o = 0
    u |> b() |> n(z) |> m() |> p(p,t,o,z,n,r,v) |> u()
  end
  
  
  
  defp x(y,x) do
    y |> d(y,x) |> e()
  end



  defp z(z) do
    [m(z,1),m(z,0),m(z,3),m(z,2)]
  end


  
  defp m(r) do
    r |> String.graphemes()
  end



  defp p(v,f,x,q) do
    "#{v - @z}#{f - @z}#{x - @z}#{q - @z}" |> NumberUtil.to_integer()
  end



  defp dm() do
    z = "pollo1"
    t = "_decip"
    t = "a#{z}8#{t}her_"
    "#{t}#{r(30)}" |> d()
  end
  
  
  
  defp d(x,t,z) do
    x |> StringUtil.replace(t,z)
  end
  
  
  
  defp r(o,w) do
    o |> Enum.chunk_every(w)
  end
  
  
  
  defp f(x) do
    cond do
      (x >= 1) -> x
      true -> 1
    end
  end
  
  
  
  defp w() do
    ["0","1","2","3","4","5","6","7","8","9"]
  end
  
  
  
  defp p(q) do
    q |> Tuple.to_list()
  end



  defp c(x,t) do
    x |> String.codepoints() |> r(t) |> Enum.map(&Enum.join/1)
  end



  defp m(y,r,w) do
    [Enum.random(@b),y,r,w] |> u()
  end
  
  

  defp j(r,m) do
    r |> Enum.join(m)
  end



  defp p(m,f,l,z,o) do
    cond do
      (!m) -> ""
      true -> f |> d(l,0,z,o)
    end
  end


 
  defp e(z) do
    z |> StringUtil.trim()
  end



  defp e(h,z,s,m,e,r) do
    p(h,[],z,0,s,m,e,r) |> u()  
  end


  
  defp y(s,x) do
    s |> Enum.member?(x)
  end

  
  
end