class HexaPDF::Encryption::StandardSecurityHandler

def check_perms_field(encryption_key)
  decrypted = aes_algorithm.new(encryption_key, "\0" * 16, :decrypt).process(dict[:Perms])
  if decrypted[9, 3] != "adb"
    raise HexaPDF::EncryptionError, "/Perms field cannot be decrypted"
  elsif (dict[:P] & 0xFFFFFFFF) != (decrypted[0, 4].unpack1('V') & 0xFFFFFFFF)
    raise HexaPDF::EncryptionError, "Decrypted permissions don't match /P"
  elsif decrypted[8] != (dict[:EncryptMetadata] ? 'T' : 'F')
    raise HexaPDF::EncryptionError, "Decrypted /Perms field doesn't match /EncryptMetadata"
  end
end

def compute_hash(password, salt, user_key = '')
  k = Digest::SHA256.digest("#{password}#{salt}#{user_key}")
  e = ''
  i = 0
  while i < 64 || e.getbyte(-1) > i - 32
    k1 = "#{password}#{k}#{user_key}" * 64
    e = aes_algorithm.new(k[0, 16], k[16, 16], :encrypt).process(k1)
    k = case e.unpack('C16').inject(&:+) % 3 # 256 % 3 == 1 % 3 --> x*256 % 3 == x % 3
        when 0 then Digest::SHA256.digest(e)
        when 1 then Digest::SHA384.digest(e)
        when 2 then Digest::SHA512.digest(e)
        end
    i += 1
  end
  k[0, 32]
end

def compute_o_field(owner_password, user_password)
  if dict[:R] <= 4
    data = Digest::MD5.digest(owner_password)
    if dict[:R] >= 3
      50.times { data = Digest::MD5.digest(data) }
    end
    key = data[0, key_length]
    data = arc4_algorithm.encrypt(key, user_password)
    if dict[:R] >= 3
      19.times {|i| data = arc4_algorithm.encrypt(xor_key(key, i + 1), data) }
    end
    data
  elsif dict[:R] == 6
    validation_salt = random_bytes(8)
    key_salt = random_bytes(8)
    compute_hash(owner_password, validation_salt, dict[:U]) << validation_salt << key_salt
  end
end

def compute_oe_field(password, file_encryption_key)
  key = compute_hash(password, dict[:O][40, 8], dict[:U])
  aes_algorithm.new(key, "\0" * 16, :encrypt).process(file_encryption_key)
end

def compute_owner_encryption_key(password)
  if dict[:R] <= 4
    compute_user_encryption_key(user_password_from_owner_password(password))
  elsif dict[:R] == 6
    key = compute_hash(password, dict[:O][40, 8], dict[:U])
    aes_algorithm.new(key, "\0" * 16, :decrypt).process(dict[:OE])
  end
end

def compute_perms_field(file_encryption_key)
  data = [dict[:P]].pack('V')
  data << [0xFFFFFFFF].pack('V')
  data << (dict[:EncryptMetadata] ? 'T' : 'F')
  data << 'adb'
  data << 'hexa'
  aes_algorithm.new(file_encryption_key, "\0" * 16, :encrypt).process(data)
end

def compute_u_field(password)
  if dict[:R] == 2
    key = compute_user_encryption_key(password)
    arc4_algorithm.encrypt(key, PASSWORD_PADDING)
  elsif dict[:R] <= 4
    key = compute_user_encryption_key(password)
    data = Digest::MD5.digest(PASSWORD_PADDING + document.trailer[:ID][0])
    data = arc4_algorithm.encrypt(key, data)
    19.times {|i| data = arc4_algorithm.encrypt(xor_key(key, i + 1), data) }
    data << "hexapdfhexapdfhe"
  elsif dict[:R] == 6
    validation_salt = random_bytes(8)
    key_salt = random_bytes(8)
    compute_hash(password, validation_salt) << validation_salt << key_salt
  end
end

def compute_ue_field(password, file_encryption_key)
  key = compute_hash(password, dict[:U][40, 8])
  aes_algorithm.new(key, "\0" * 16, :encrypt).process(file_encryption_key)
end

def compute_user_encryption_key(password)
  if dict[:R] <= 4
    data = password
    data += dict[:O]
    data << [dict[:P]].pack('V')
    data << document.trailer[:ID][0]
    data << [0xFFFFFFFF].pack('V') if dict[:R] == 4 && !dict[:EncryptMetadata]
    n = key_length
    data = Digest::MD5.digest(data)
    if dict[:R] >= 3
      50.times { data = Digest::MD5.digest(data[0, n]) }
    end
    data[0, n]
  elsif dict[:R] == 6
    key = compute_hash(password, dict[:U][40, 8])
    aes_algorithm.new(key, "\0" * 16, :decrypt).process(dict[:UE])
  end
end

def decrypt(obj) #:nodoc:
  if dict[:V] >= 4 && obj.type == :Metadata && obj[:Subtype] == :XML && !dict[:EncryptMetadata]
    obj
  else
    super
  end
end

def encrypt_stream(obj) #:nodoc
  if dict[:V] >= 4 && obj.type == :Metadata && obj[:Subtype] == :XML && !dict[:EncryptMetadata]
    obj.stream_encoder
  else
    super
  end
end

def encryption_dictionary_class
  StandardEncryptionDictionary
end

def encryption_key_valid?
  super && (document.trailer[:Encrypt][:R] > 4 || trailer_id_hash == @trailer_id_hash)
end

def owner_password_valid?(password)
  if dict[:R] <= 4
    user_password_valid?(user_password_from_owner_password(password))
  elsif dict[:R] == 6
    compute_hash(password, dict[:O][32, 8], dict[:U]) == dict[:O][0, 32]
  end
end

def permissions
  Permissions::PERMISSION_TO_SYMBOL.each_with_object([]) do |(perm, sym), result|
    result << sym if dict[:P] & perm == perm
  end
end

def prepare_decryption(password: '', check_permissions: true)
  if dict[:Filter] != :Standard
    raise(HexaPDF::UnsupportedEncryptionError,
          "Invalid /Filter value #{dict[:Filter]} for standard security handler")
  elsif ![2, 3, 4, 6].include?(dict[:R])
    raise(HexaPDF::UnsupportedEncryptionError,
          "Invalid /R value #{dict[:R]} for standard security handler")
  elsif dict[:R] <= 4 && !document.trailer[:ID].kind_of?(PDFArray)
    document.trailer[:ID] = ['', '']
  end
  @trailer_id_hash = trailer_id_hash
  password = prepare_password(password)
  if user_password_valid?(prepare_password(''))
    encryption_key = compute_user_encryption_key(prepare_password(''))
  elsif user_password_valid?(password)
    encryption_key = compute_user_encryption_key(password)
  elsif owner_password_valid?(password)
    encryption_key = compute_owner_encryption_key(password)
  else
    raise HexaPDF::EncryptionError, "Invalid password specified"
  end
  check_perms_field(encryption_key) if check_permissions && dict[:R] == 6
  encryption_key
end

def prepare_encryption(**kwoptions)
  options = EncryptionOptions.new(kwoptions)
  dict[:Filter] = :Standard
  dict[:R] = case dict[:V]
             when 1 then 2
             when 2 then 3
             when 4 then 4
             when 5 then 6
             end
  dict[:EncryptMetadata] = options.encrypt_metadata
  dict[:P] = options.permissions
  if dict[:V] >= 4
    cfm = if options.algorithm == :arc4
            :V2
          elsif key_length == 16
            :AESV2
          else
            :AESV3
          end
    dict[:CF] = {
      StdCF: {
        CFM: cfm,
        AuthEvent: :DocOpen,
        Length: key_length,
      },
    }
    dict[:StmF] = dict[:StrF] = :StdCF
  end
  if dict[:R] <= 4 && !document.trailer[:ID].kind_of?(PDFArray)
    document.trailer.set_random_id
  end
  options.user_password = prepare_password(options.user_password)
  options.owner_password = prepare_password(options.owner_password)
  dict[:O] = compute_o_field(options.owner_password, options.user_password)
  dict[:U] = compute_u_field(options.user_password)
  if dict[:R] <= 4
    encryption_key = compute_user_encryption_key(options.user_password)
  else
    encryption_key = random_bytes(32)
    dict[:UE] = compute_ue_field(options.user_password, encryption_key)
    dict[:OE] = compute_oe_field(options.owner_password, encryption_key)
    dict[:Perms] = compute_perms_field(encryption_key)
  end
  @trailer_id_hash = trailer_id_hash
  [encryption_key, options.algorithm, options.algorithm, options.algorithm]
end

def prepare_password(password)
  if dict[:R] <= 4
    password.to_s[0, 32].encode(Encoding::ISO_8859_1).force_encoding(Encoding::BINARY).
      ljust(32, PASSWORD_PADDING)
  elsif dict[:R] == 6
    password.to_s.encode(Encoding::UTF_8).force_encoding(Encoding::BINARY)[0, 127]
  end
rescue Encoding::UndefinedConversionError => e
  raise HexaPDF::EncryptionError, "Invalid character in password: #{e.error_char}"
end

def trailer_id_hash # :nodoc:
  id = document.unwrap(document.trailer[:ID])
  (id.kind_of?(Array) ? id[0] : id).hash
end

def user_password_from_owner_password(owner_password)
  data = Digest::MD5.digest(owner_password)
  if dict[:R] >= 3
    50.times { data = Digest::MD5.digest(data) }
  end
  key = data[0, key_length]
  if dict[:R] == 2
    userpwd = arc4_algorithm.decrypt(key, dict[:O])
  else
    userpwd = dict[:O]
    20.times {|i| userpwd = arc4_algorithm.decrypt(xor_key(key, 19 - i), userpwd) }
  end
  userpwd
end

def user_password_valid?(password)
  if dict[:R] == 2
    compute_u_field(password) == dict[:U]
  elsif dict[:R] <= 4
    compute_u_field(password)[0, 16] == dict[:U][0, 16]
  elsif dict[:R] == 6
    compute_hash(password, dict[:U][32, 8]) == dict[:U][0, 32]
  end
end

def xor_key(key, value)
  new_key = key.dup
  i = 0
  while i < new_key.length
    new_key.setbyte(i, (new_key.getbyte(i) ^ value) % 256)
    i += 1
  end
  new_key
end