/*
* (C) 2017 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/exceptn.h>

namespace Botan {

std::string to_string(ErrorType type)
{
   switch(type)
   {
   case ErrorType::Unknown:
      return "Unknown";
   case ErrorType::SystemError:
      return "SystemError";
   case ErrorType::NotImplemented:
      return "NotImplemented";
   case ErrorType::OutOfMemory:
      return "OutOfMemory";
   case ErrorType::InternalError:
      return "InternalError";
   case ErrorType::IoError:
      return "IoError";
   case ErrorType::InvalidObjectState :
      return "InvalidObjectState";
   case ErrorType::KeyNotSet:
      return "KeyNotSet";
   case ErrorType::InvalidArgument:
      return "InvalidArgument";
   case ErrorType::InvalidKeyLength:
      return "InvalidKeyLength";
   case ErrorType::InvalidNonceLength:
      return "InvalidNonceLength";
   case ErrorType::LookupError:
      return "LookupError";
   case ErrorType::EncodingFailure:
      return "EncodingFailure";
   case ErrorType::DecodingFailure:
      return "DecodingFailure";
   case ErrorType::TLSError:
      return "TLSError";
   case ErrorType::HttpError:
      return "HttpError";
   case ErrorType::InvalidTag:
      return "InvalidTag";
   case ErrorType::OpenSSLError :
      return "OpenSSLError";
   case ErrorType::CommonCryptoError:
      return "CommonCryptoError";
   case ErrorType::Pkcs11Error:
      return "Pkcs11Error";
   case ErrorType::TPMError:
      return "TPMError";
   case ErrorType::ZlibError :
      return "ZlibError";
   case ErrorType::Bzip2Error:
      return "Bzip2Error" ;
   case ErrorType::LzmaError:
      return "LzmaError";

   default:
      return "unrecognized botan error";
   }
}

Exception::Exception(const std::string& msg) : m_msg(msg)
   {}

Exception::Exception(const std::string& msg, const std::exception& e) :
   m_msg(msg + " failed with " + std::string(e.what()))
   {}

Exception::Exception(const char* prefix, const std::string& msg) :
   m_msg(std::string(prefix) + " " + msg)
   {}

Invalid_Argument::Invalid_Argument(const std::string& msg) :
   Exception(msg)
   {}

Invalid_Argument::Invalid_Argument(const std::string& msg, const std::string& where) :
   Exception(msg + " in " + where)
   {}

Invalid_Argument::Invalid_Argument(const std::string& msg, const std::exception& e) :
   Exception(msg, e) {}

Lookup_Error::Lookup_Error(const std::string& type,
                           const std::string& algo,
                           const std::string& provider) :
   Exception("Unavailable " + type + " " + algo +
             (provider.empty() ? std::string("") : (" for provider " + provider)))
   {}

Internal_Error::Internal_Error(const std::string& err) :
   Exception("Internal error: " + err)
   {}

Invalid_Key_Length::Invalid_Key_Length(const std::string& name, size_t length) :
   Invalid_Argument(name + " cannot accept a key of length " +
                    std::to_string(length))
   {}

Invalid_IV_Length::Invalid_IV_Length(const std::string& mode, size_t bad_len) :
   Invalid_Argument("IV length " + std::to_string(bad_len) +
                    " is invalid for " + mode)
   {}

Key_Not_Set::Key_Not_Set(const std::string& algo) :
   Invalid_State("Key not set in " + algo)
   {}

Policy_Violation::Policy_Violation(const std::string& err) :
   Invalid_State("Policy violation: " + err) {}

PRNG_Unseeded::PRNG_Unseeded(const std::string& algo) :
   Invalid_State("PRNG not seeded: " + algo)
   {}

Algorithm_Not_Found::Algorithm_Not_Found(const std::string& name) :
   Lookup_Error("Could not find any algorithm named \"" + name + "\"")
   {}

No_Provider_Found::No_Provider_Found(const std::string& name) :
   Exception("Could not find any provider for algorithm named \"" + name + "\"")
   {}

Provider_Not_Found::Provider_Not_Found(const std::string& algo, const std::string& provider) :
   Lookup_Error("Could not find provider '" + provider + "' for " + algo)
   {}

Invalid_Algorithm_Name::Invalid_Algorithm_Name(const std::string& name):
   Invalid_Argument("Invalid algorithm name: " + name)
   {}

Encoding_Error::Encoding_Error(const std::string& name) :
   Invalid_Argument("Encoding error: " + name)
   {}

Decoding_Error::Decoding_Error(const std::string& name) :
   Invalid_Argument(name)
   {}

Decoding_Error::Decoding_Error(const std::string& msg, const std::exception& e) :
   Invalid_Argument(msg, e)
   {}

Decoding_Error::Decoding_Error(const std::string& name, const char* exception_message) :
   Invalid_Argument(name + " failed with exception " + exception_message) {}

Invalid_Authentication_Tag::Invalid_Authentication_Tag(const std::string& msg) :
   Exception("Invalid authentication tag: " + msg)
   {}

Invalid_OID::Invalid_OID(const std::string& oid) :
   Decoding_Error("Invalid ASN.1 OID: " + oid)
   {}

Stream_IO_Error::Stream_IO_Error(const std::string& err) :
   Exception("I/O error: " + err)
   {}

System_Error::System_Error(const std::string& msg, int err_code) :
   Exception(msg + " error code " + std::to_string(err_code)),
   m_error_code(err_code)
   {}

Self_Test_Failure::Self_Test_Failure(const std::string& err) :
   Internal_Error("Self test failed: " + err)
   {}

Not_Implemented::Not_Implemented(const std::string& err) :
   Exception("Not implemented", err)
   {}

}