//
//  MD5.swift
//  Marvel
//
//  Created by Douglas Nunes on 30/03/22.
//

import Foundation

import Foundation

// MARK: - Public
public func MD5(_ input: String) -> String {
  return hex_md5(input)
}

// MARK: - Functions
func hex_md5(_ input: String) -> String {
  return rstr2hex(rstr_md5(str2rstr_utf8(input)))
}

func str2rstr_utf8(_ input: String) -> [CUnsignedChar] {
  return Array(input.utf8)
}

func rstr2tr(_ input: [CUnsignedChar]) -> String {
  var output: String = ""

  input.forEach {
	output.append(String(UnicodeScalar($0)))
  }

  return output
}

/*
 * Convert a raw string to a hex string
 */
func rstr2hex(_ input: [CUnsignedChar]) -> String {
  let hexTab: [Character] = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
  var output: [Character] = []

  for i in 0..<input.count {
	let x = input[i]
	let value1 = hexTab[Int((x >> 4) & 0x0F)]
	let value2 = hexTab[Int(Int32(x) & 0x0F)]

	output.append(value1)
	output.append(value2)
  }

  return String(output)
}

/*
 * Convert a raw string to an array of little-endian words
 * Characters >255 have their high-byte silently ignored.
 */
func rstr2binl(_ input: [CUnsignedChar]) -> [Int32] {
  var output: [Int: Int32] = [:]

  for i in stride(from: 0, to: input.count * 8, by: 8) {
	let value: Int32 = (Int32(input[i/8]) & 0xFF) << (Int32(i) % 32)

	output[i >> 5] = unwrap(output[i >> 5]) | value
  }

  return dictionary2array(output)
}

/*
 * Convert an array of little-endian words to a string
 */
func binl2rstr(_ input: [Int32]) -> [CUnsignedChar] {
  var output: [CUnsignedChar] = []

  for i in stride(from: 0, to: input.count * 32, by: 8) {
	// [i>>5] >>>
	let value: Int32 = zeroFillRightShift(input[i>>5], Int32(i % 32)) & 0xFF
	output.append(CUnsignedChar(value))
  }

  return output
}

/*
 * Calculate the MD5 of a raw string
 */
func rstr_md5(_ input: [CUnsignedChar]) -> [CUnsignedChar] {
  return binl2rstr(binl_md5(rstr2binl(input), input.count * 8))
}

/*
 * Add integers, wrapping at 2^32.
 */
func safe_add(_ x: Int32, _ y: Int32) -> Int32 {
  return x &+ y
}

/*
 * Bitwise rotate a 32-bit number to the left.
 */
func bit_rol(_ num: Int32, _ cnt: Int32) -> Int32 {
  // num >>>
  return (num << cnt) | zeroFillRightShift(num, (32 - cnt))
}


/*
 * These funcs implement the four basic operations the algorithm uses.
 */
func md5_cmn(_ q: Int32, _ a: Int32, _ b: Int32, _ x: Int32, _ s: Int32, _ t: Int32) -> Int32 {
  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b)
}

func md5_ff(_ a: Int32, _ b: Int32, _ c: Int32, _ d: Int32, _ x: Int32, _ s: Int32, _ t: Int32) -> Int32 {
  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t)
}

func md5_gg(_ a: Int32, _ b: Int32, _ c: Int32, _ d: Int32, _ x: Int32, _ s: Int32, _ t: Int32) -> Int32 {
  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t)
}

func md5_hh(_ a: Int32, _ b: Int32, _ c: Int32, _ d: Int32, _ x: Int32, _ s: Int32, _ t: Int32) -> Int32 {
  return md5_cmn(b ^ c ^ d, a, b, x, s, t)
}

func md5_ii(_ a: Int32, _ b: Int32, _ c: Int32, _ d: Int32, _ x: Int32, _ s: Int32, _ t: Int32) -> Int32 {
  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t)
}


/*
 * Calculate the MD5 of an array of little-endian words, and a bit length.
 */
func binl_md5(_ input: [Int32], _ len: Int) -> [Int32] {
  /* append padding */

  var x: [Int: Int32] = [:]
  for (index, value) in input.enumerated() {
	x[index] = value
  }

  let value: Int32 = 0x80 << Int32((len) % 32)
  x[len >> 5] = unwrap(x[len >> 5]) | value

  // >>> 9
  let index = (((len + 64) >> 9) << 4) + 14
  x[index] = unwrap(x[index]) | Int32(len)

  var a: Int32 =  1732584193
  var b: Int32 = -271733879
  var c: Int32 = -1732584194
  var d: Int32 =  271733878

  for i in stride(from: 0, to: length(x), by: 16) {
	let olda: Int32 = a
	let oldb: Int32 = b
	let oldc: Int32 = c
	let oldd: Int32 = d

	a = md5_ff(a, b, c, d, unwrap(x[i + 0]), 7 , -680876936)
	d = md5_ff(d, a, b, c, unwrap(x[i + 1]), 12, -389564586)
	c = md5_ff(c, d, a, b, unwrap(x[i + 2]), 17,  606105819)
	b = md5_ff(b, c, d, a, unwrap(x[i + 3]), 22, -1044525330)
	a = md5_ff(a, b, c, d, unwrap(x[i + 4]), 7 , -176418897)
	d = md5_ff(d, a, b, c, unwrap(x[i + 5]), 12,  1200080426)
	c = md5_ff(c, d, a, b, unwrap(x[i + 6]), 17, -1473231341)
	b = md5_ff(b, c, d, a, unwrap(x[i + 7]), 22, -45705983)
	a = md5_ff(a, b, c, d, unwrap(x[i + 8]), 7 ,  1770035416)
	d = md5_ff(d, a, b, c, unwrap(x[i + 9]), 12, -1958414417)
	c = md5_ff(c, d, a, b, unwrap(x[i + 10]), 17, -42063)
	b = md5_ff(b, c, d, a, unwrap(x[i + 11]), 22, -1990404162)
	a = md5_ff(a, b, c, d, unwrap(x[i + 12]), 7 ,  1804603682)
	d = md5_ff(d, a, b, c, unwrap(x[i + 13]), 12, -40341101)
	c = md5_ff(c, d, a, b, unwrap(x[i + 14]), 17, -1502002290)
	b = md5_ff(b, c, d, a, unwrap(x[i + 15]), 22,  1236535329)

	a = md5_gg(a, b, c, d, unwrap(x[i + 1]), 5 , -165796510)
	d = md5_gg(d, a, b, c, unwrap(x[i + 6]), 9 , -1069501632)
	c = md5_gg(c, d, a, b, unwrap(x[i + 11]), 14,  643717713)
	b = md5_gg(b, c, d, a, unwrap(x[i + 0]), 20, -373897302)
	a = md5_gg(a, b, c, d, unwrap(x[i + 5]), 5 , -701558691)
	d = md5_gg(d, a, b, c, unwrap(x[i + 10]), 9 ,  38016083)
	c = md5_gg(c, d, a, b, unwrap(x[i + 15]), 14, -660478335)
	b = md5_gg(b, c, d, a, unwrap(x[i + 4]), 20, -405537848)
	a = md5_gg(a, b, c, d, unwrap(x[i + 9]), 5 ,  568446438)
	d = md5_gg(d, a, b, c, unwrap(x[i + 14]), 9 , -1019803690)
	c = md5_gg(c, d, a, b, unwrap(x[i + 3]), 14, -187363961)
	b = md5_gg(b, c, d, a, unwrap(x[i + 8]), 20,  1163531501)
	a = md5_gg(a, b, c, d, unwrap(x[i + 13]), 5 , -1444681467)
	d = md5_gg(d, a, b, c, unwrap(x[i + 2]), 9 , -51403784)
	c = md5_gg(c, d, a, b, unwrap(x[i + 7]), 14,  1735328473)
	b = md5_gg(b, c, d, a, unwrap(x[i + 12]), 20, -1926607734)

	a = md5_hh(a, b, c, d, unwrap(x[i + 5]), 4 , -378558)
	d = md5_hh(d, a, b, c, unwrap(x[i + 8]), 11, -2022574463)
	c = md5_hh(c, d, a, b, unwrap(x[i + 11]), 16,  1839030562)
	b = md5_hh(b, c, d, a, unwrap(x[i + 14]), 23, -35309556)
	a = md5_hh(a, b, c, d, unwrap(x[i + 1]), 4 , -1530992060)
	d = md5_hh(d, a, b, c, unwrap(x[i + 4]), 11,  1272893353)
	c = md5_hh(c, d, a, b, unwrap(x[i + 7]), 16, -155497632)
	b = md5_hh(b, c, d, a, unwrap(x[i + 10]), 23, -1094730640)
	a = md5_hh(a, b, c, d, unwrap(x[i + 13]), 4 ,  681279174)
	d = md5_hh(d, a, b, c, unwrap(x[i + 0]), 11, -358537222)
	c = md5_hh(c, d, a, b, unwrap(x[i + 3]), 16, -722521979)
	b = md5_hh(b, c, d, a, unwrap(x[i + 6]), 23,  76029189)
	a = md5_hh(a, b, c, d, unwrap(x[i + 9]), 4 , -640364487)
	d = md5_hh(d, a, b, c, unwrap(x[i + 12]), 11, -421815835)
	c = md5_hh(c, d, a, b, unwrap(x[i + 15]), 16,  530742520)
	b = md5_hh(b, c, d, a, unwrap(x[i + 2]), 23, -995338651)

	a = md5_ii(a, b, c, d, unwrap(x[i + 0]), 6 , -198630844)
	d = md5_ii(d, a, b, c, unwrap(x[i + 7]), 10,  1126891415)
	c = md5_ii(c, d, a, b, unwrap(x[i + 14]), 15, -1416354905)
	b = md5_ii(b, c, d, a, unwrap(x[i + 5]), 21, -57434055)
	a = md5_ii(a, b, c, d, unwrap(x[i + 12]), 6 ,  1700485571)
	d = md5_ii(d, a, b, c, unwrap(x[i + 3]), 10, -1894986606)
	c = md5_ii(c, d, a, b, unwrap(x[i + 10]), 15, -1051523)
	b = md5_ii(b, c, d, a, unwrap(x[i + 1]), 21, -2054922799)
	a = md5_ii(a, b, c, d, unwrap(x[i + 8]), 6 ,  1873313359)
	d = md5_ii(d, a, b, c, unwrap(x[i + 15]), 10, -30611744)
	c = md5_ii(c, d, a, b, unwrap(x[i + 6]), 15, -1560198380)
	b = md5_ii(b, c, d, a, unwrap(x[i + 13]), 21,  1309151649)
	a = md5_ii(a, b, c, d, unwrap(x[i + 4]), 6 , -145523070)
	d = md5_ii(d, a, b, c, unwrap(x[i + 11]), 10, -1120210379)
	c = md5_ii(c, d, a, b, unwrap(x[i + 2]), 15,  718787259)
	b = md5_ii(b, c, d, a, unwrap(x[i + 9]), 21, -343485551)

	a = safe_add(a, olda)
	b = safe_add(b, oldb)
	c = safe_add(c, oldc)
	d = safe_add(d, oldd)
  }

  return [a, b, c, d]
}

// MARK: - Helper
func length(_ dictionary: [Int: Int32]) -> Int {
  return (dictionary.keys.max() ?? 0) + 1
}

func dictionary2array(_ dictionary: [Int: Int32]) -> [Int32] {
  var array = Array<Int32>(repeating: 0, count: dictionary.keys.count)

  for i in Array(dictionary.keys).sorted() {
	array[i] = unwrap(dictionary[i])
  }

  return array
}

func unwrap(_ value: Int32?, _ fallback: Int32 = 0) -> Int32 {
  if let value = value {
	return value
  }

  return fallback
}

func zeroFillRightShift(_ num: Int32, _ count: Int32) -> Int32 {
  let value = UInt32(bitPattern: num) >> UInt32(bitPattern: count)
  return Int32(bitPattern: value)
}

func hashMD5(timestamp: String) -> String {
	
	let hash = "\(timestamp)\(Environment.privateKey)\(Environment.publicKey)"
	
	return MD5(hash).lowercased()
}

