import {GhostError, GhostErrorOptions} from './GhostError';

const mergeOptions = (options: GhostErrorOptions, defaults: GhostErrorOptions) => {
    const result = {...defaults};

    // Ignore undefined options - for example passing statusCode: undefined should not override the default
    (Object.keys(options) as (keyof GhostErrorOptions)[]).forEach((key) => {
        if (options[key] !== undefined) {
            result[key] = options[key];
        }
    });

    return result;
};

export class InternalServerError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 500,
            level: 'critical',
            errorType: 'InternalServerError',
            message: 'The server has encountered an error.'
        }));
    }
}

export class IncorrectUsageError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 400,
            level: 'critical',
            errorType: 'IncorrectUsageError',
            message: 'We detected a misuse. Please read the stack trace.'
        }));
    }
}

export class NotFoundError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 404,
            errorType: 'NotFoundError',
            message: 'Resource could not be found.',
            hideStack: true
        }));
    }
}

export class BadRequestError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 400,
            errorType: 'BadRequestError',
            message: 'The request could not be understood.'
        }));
    }
}

export class UnauthorizedError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 401,
            errorType: 'UnauthorizedError',
            message: 'You are not authorised to make this request.'
        }));
    }
}

export class NoPermissionError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 403,
            errorType: 'NoPermissionError',
            message: 'You do not have permission to perform this request.'
        }));
    }
}

export class ValidationError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 422,
            errorType: 'ValidationError',
            message: 'The request failed validation.'
        }));
    }
}

export class UnsupportedMediaTypeError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 415,
            errorType: 'UnsupportedMediaTypeError',
            message: 'The media in the request is not supported by the server.'
        }));
    }
}

export class TooManyRequestsError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 429,
            errorType: 'TooManyRequestsError',
            message: 'Server has received too many similar requests in a short space of time.'
        }));
    }
}

export class MaintenanceError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 503,
            errorType: 'MaintenanceError',
            message: 'The server is temporarily down for maintenance.'
        }));
    }
}

export class MethodNotAllowedError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 405,
            errorType: 'MethodNotAllowedError',
            message: 'Method not allowed for resource.'
        }));
    }
}

export class RequestNotAcceptableError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 406,
            errorType: 'RequestNotAcceptableError',
            message: 'Request not acceptable for provided Accept-Version header.',
            hideStack: true
        }));
    }
}

export class RangeNotSatisfiableError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 416,
            errorType: 'RangeNotSatisfiableError',
            message: 'Range not satisfiable for provided Range header.',
            hideStack: true
        }));
    }
}

export class RequestEntityTooLargeError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 413,
            errorType: 'RequestEntityTooLargeError',
            message: 'Request was too big for the server to handle.'
        }));
    }
}

export class TokenRevocationError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 503,
            errorType: 'TokenRevocationError',
            message: 'Token is no longer available.'
        }));
    }
}

export class VersionMismatchError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 400,
            errorType: 'VersionMismatchError',
            message: 'Requested version does not match server version.'
        }));
    }
}

export class DataExportError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 500,
            errorType: 'DataExportError',
            message: 'The server encountered an error whilst exporting data.'
        }));
    }
}

export class DataImportError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 500,
            errorType: 'DataImportError',
            message: 'The server encountered an error whilst importing data.'
        }));
    }
}

export class EmailError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 500,
            errorType: 'EmailError',
            message: 'The server encountered an error whilst sending email.'
        }));
    }
}

export class ThemeValidationError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 422,
            errorType: 'ThemeValidationError',
            message: 'The theme has a validation error.',
            errorDetails: {}
        }));
    }
}

export class DisabledFeatureError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 409,
            errorType: 'DisabledFeatureError',
            message: 'Unable to complete the request, this feature is disabled.'
        }));
    }
}

export class UpdateCollisionError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            statusCode: 409,
            errorType: 'UpdateCollisionError',
            message: 'Unable to complete the request, there was a conflict.'
        }));
    }
}

export class HostLimitError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            errorType: 'HostLimitError',
            hideStack: true,
            statusCode: 403,
            message: 'Unable to complete the request, this resource is limited.'
        }));
    }
}

export class HelperWarning extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            errorType: 'HelperWarning',
            hideStack: true,
            statusCode: 400,
            message: 'A theme helper has done something unexpected.'
        }));
    }
}

export class PasswordResetRequiredError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            errorType: 'PasswordResetRequiredError',
            statusCode: 401,
            message: 'For security, you need to create a new password. An email has been sent to you with instructions!'
        }));
    }
}

export class UnhandledJobError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            errorType: 'UnhandledJobError',
            message: 'Processed job threw an unhandled error',
            level: 'critical'
        }));
    }
}

export class NoContentError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            errorType: 'NoContentError',
            statusCode: 204,
            hideStack: true
        }));
    }
}

export class ConflictError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            errorType: 'ConflictError',
            statusCode: 409,
            message: 'The server has encountered an conflict.'
        }));
    }
}

export class MigrationError extends GhostError {
    constructor(options: GhostErrorOptions = {}) {
        super(mergeOptions(options, {
            errorType: 'MigrationError',
            message: 'An error has occurred applying a database migration.',
            level: 'critical'
        }));
    }
}