#include "Error.hpp"

std::string NSLocalizedDescriptionKey = "NSLocalizedDescription";

std::string NSLocalizedFailureErrorKey = "NSLocalizedFailure";

std::string NSLocalizedFailureReasonErrorKey = "NSLocalizedFailureReason";

std::string NSLocalizedRecoverySuggestionErrorKey = "NSLocalizedRecoverySuggestion";

std::string NSUnderlyingErrorKey = "NSUnderlyingError";

std::string NSDebugDescriptionErrorKey = "NSDebugDescription";

std::string ALTLocalizedDescriptionKey = "ALTLocalizedDescription";

std::string ALTLocalizedFailureReasonErrorKey = "ALTLocalizedFailureReason";

std::string ALTLocalizedRecoverySuggestionErrorKey = "ALTLocalizedRecoverySuggestion";

std::string ALTDebugDescriptionErrorKey = "ALTDebugDescription";

extern std::wstring WideStringFromString(std::string string);

std::string AnyStringValue(std::any& any)

{

try

{

std::string string = std::any_cast<std::string>(any);

return string;

}

catch (std::bad_any_cast) {}

try

{

std::optional<std::string> string = std::any_cast<std::optional<std::string>>(any);

if (string.has_value())

{

return *string;

}

else

{

return "";

}

}

catch (std::bad_any_cast) {}

try

{

char* string = std::any_cast<char*>(any);

return string;

}

catch (std::bad_any_cast) {}

try

{

const char* string = std::any_cast<const char*>(any);

return string;

}

catch (std::bad_any_cast) {}

try

{

int number = std::any_cast<int>(any);

return std::to_string(number);

}

catch (std::bad_any_cast) {}

std::shared_ptr<Error> error = std::any_cast<std::shared_ptr<Error>>(any);

std::ostringstream oss;

oss << *error;

return oss.str();

}

web::json::value Error::serialized() const

{

web::json::value serializedError = web::json::value();

serializedError[L"errorDomain"] = web::json::value::string(WideStringFromString(this->domain()));

serializedError[L"errorCode"] = web::json::value::number(this->code());

auto rawUserInfo = this->userInfo();

web::json::value userInfo;

for (auto pair : rawUserInfo)

{

try

{

std::string string = AnyStringValue(pair.second);

userInfo[WideStringFromString(pair.first)] = web::json::value::string(WideStringFromString(string));

continue;

}

catch (std::bad_any_cast) {}

try

{

int integer = std::any_cast<int>(pair.second);

userInfo[WideStringFromString(pair.first)] = web::json::value::number(integer);

continue;

}

catch (std::bad_any_cast) {}

try

{

auto error = std::any_cast<std::shared_ptr<Error>>(pair.second);

userInfo[WideStringFromString(pair.first)] = error->serialized();

continue;

}

catch (std::bad_any_cast) {}

// TODO: Support std::vector<std::any> and std::map<std::string, std::any>

// We can get away with this for now because we don't store either in error user info (yet).

}

userInfo[WideStringFromString(ALTLocalizedDescriptionKey)] = web::json::value::string(WideStringFromString(this->localizedDescription()));

auto localizedFailureReason = this->localizedFailureReason();

if (localizedFailureReason.has_value())

{

userInfo[WideStringFromString(ALTLocalizedFailureReasonErrorKey)] = web::json::value::string(WideStringFromString(*localizedFailureReason));

}

auto localizedRecoverySuggestion = this->localizedRecoverySuggestion();

if (localizedRecoverySuggestion.has_value())

{

userInfo[WideStringFromString(ALTLocalizedRecoverySuggestionErrorKey)] = web::json::value::string(WideStringFromString(*localizedRecoverySuggestion));

}

auto debugDescription = this->localizedDebugDescription();

if (debugDescription.has_value())

{

userInfo[WideStringFromString(ALTDebugDescriptionErrorKey)] = web::json::value::string(WideStringFromString(*debugDescription));

}

web::json::value legacyUserInfo;

for (auto pair : rawUserInfo)

{

try

{

auto value = AnyStringValue(pair.second);

legacyUserInfo[WideStringFromString(pair.first)] = web::json::value::string(WideStringFromString(value));

}

catch (std::bad_any_cast)

{

// legacyUserInfo only supports string values, so ignore all non-string values.

}

}

serializedError[L"errorUserInfo"] = userInfo;

serializedError[L"userInfo"] = legacyUserInfo;

return serializedError;

}

std::string Error::formattedDetailedDescription() const

{

std::vector<std::string> preferredKeyOrder = {

NSDebugDescriptionErrorKey,

NSLocalizedDescriptionKey,

NSLocalizedFailureErrorKey,

NSLocalizedFailureReasonErrorKey,

NSLocalizedRecoverySuggestionErrorKey,

NSUnderlyingErrorKey,

};

auto userInfo = this->userInfo();

userInfo[NSLocalizedDescriptionKey] = this->localizedDescription();

auto localizedFailure = this->localizedFailure();

if (localizedFailure.has_value())

{

userInfo[NSLocalizedFailureErrorKey] = *localizedFailure;

}

auto localizedFailureReason = this->localizedFailureReason();

if (localizedFailureReason.has_value())

{

userInfo[NSLocalizedFailureReasonErrorKey] = *localizedFailureReason;

}

auto localizedRecoverySuggestion = this->localizedRecoverySuggestion();

if (localizedRecoverySuggestion.has_value())

{

userInfo[NSLocalizedRecoverySuggestionErrorKey] = *localizedRecoverySuggestion;

}

auto localizedDebugDescription = this->localizedDebugDescription();

if (localizedDebugDescription.has_value())

{

userInfo[NSDebugDescriptionErrorKey] = *localizedDebugDescription;

}

std::vector<std::pair<std::string, std::any>> sortedUserInfo;

for (auto& pair : userInfo)

{

sortedUserInfo.push_back(pair);

}

sort(sortedUserInfo.begin(), sortedUserInfo.end(), [preferredKeyOrder](auto& a, auto& b) {

auto indexA = find(preferredKeyOrder.begin(), preferredKeyOrder.end(), a.first);

auto indexB = find(preferredKeyOrder.begin(), preferredKeyOrder.end(), b.first);

if (indexA != preferredKeyOrder.end() && indexB != preferredKeyOrder.end())

{

return indexA < indexB;

}

else if (indexA != preferredKeyOrder.end() && indexB == preferredKeyOrder.end())

{

// indexA exists, indexB does not, so A should come first.

return true;

}

else if (indexA == preferredKeyOrder.end() && indexB != preferredKeyOrder.end())

{

// indexA does not exist, indexB does, so B should come first.

return false;

}

else

{

// both indexes are nil, so sort alphabetically.

return a.first < b.first;

}

});

std::string detailedDescription;

for (auto& pair : sortedUserInfo)

{

std::string value;

try

{

value = AnyStringValue(pair.second);

}

catch (std::bad_any_cast)

{

continue;

}

std::string keyName;

if (pair.first == NSDebugDescriptionErrorKey)

{

keyName = "Debug Description";

}

else if (pair.first == NSLocalizedDescriptionKey)

{

keyName = "Error Description";

}

else if (pair.first == NSLocalizedFailureErrorKey)

{

keyName = "Failure";

}

else if (pair.first == NSLocalizedFailureReasonErrorKey)

{

keyName = "Failure Reason";

}

else if (pair.first == NSLocalizedRecoverySuggestionErrorKey)

{

keyName = "Recovery Suggestion";

}

else if (pair.first == NSUnderlyingErrorKey)

{

keyName = "Underlying Error";

}

else

{

keyName = pair.first;

}

std::string string = keyName + "\n" + value;

if (detailedDescription.length() > 0)

{

detailedDescription += "\n\n";

}

detailedDescription += string;

}

return detailedDescription;

}