import { ServerRoute } from '@hapi/hapi'
import { PostHandler } from '../handlers/post.handler'
import { options } from "../validators/global.validator.schema"
import { Common } from "../../utils/common"
import {
    postResponse,
    postRequest,
    postIdentifier,
    postStringIdentifier,
    postTypeIdentifier,
    postListRequest,
    postListResponse,
    postListAllRequest,
    postListAllResponse,
    postSortOrderRequest,
    postStatusRequest,
    postPublicListResponse,
    postPublicListRequest,
    postTagsListRequest,
    postOnlyIdentifier,
    postPublicResponse,
    postPublicDetailResponse,
    postOnlyCodeIdentifier,
    postPublicPageListResponse
} from "../validators/post.validator"
const postHandler = new PostHandler();
import { I18N } from '../../utils/i18n';
import { error400, error401, error403, error404, error500, confirmationOnly } from "../validators/global.validator.schema"
const routes: ServerRoute[] = [
    {
        method: 'POST',
        path: '/post',
        handler: postHandler.create,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('CREATE_POST_DESCRIPTION'),
            notes: I18N.t('CREATE_POST_NOTE'),
            plugins: { 'hapi-swagger': { order: 1 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: postRequest,
            },
            response: {
                status: {
                    201: postResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'GET',
        path: '/post/{postType}/{id}',
        handler: postHandler.getById,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('GET_POST_BY_ID_DESCRIPTION'),
            notes: I18N.t('GET_POST_BY_ID_NOTE'),
            plugins: { 'hapi-swagger': { order: 2 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postIdentifier
            },
            response: {
                status: {
                    200: postResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/post/{postType}/{code}/byCode',
        handler: postHandler.getByCode,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('GET_POST_BY_CODE_DESCRIPTION'),
            notes: I18N.t('GET_POST_BY_CODE_NOTE'),
            plugins: { 'hapi-swagger': { order: 3 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postStringIdentifier
            },
            response: {
                status: {
                    200: postResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'PATCH',
        path: '/post/{postType}/{id}',
        handler: postHandler.update,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('UPDATE_POST_DESCRIPTION'),
            notes: I18N.t('UPDATE_POST_NOTE'),
            plugins: { 'hapi-swagger': { order: 4 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'user', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: postRequest,
                params: postIdentifier
            },
            response: {
                status: {
                    200: postResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'DELETE',
        path: '/post/{postType}/{id}',
        handler: postHandler.delete,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('DELETE_POST_DESCRIPTION'),
            notes: I18N.t('DELETE_POST_NOTE'),
            plugins: { 'hapi-swagger': { order: 5 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postIdentifier
            },
            response: {
                status: {
                    200: postResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'GET',
        path: '/post/{postType}/list',
        handler: postHandler.list,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('LIST_POST_DESCRIPTION'),
            notes: I18N.t('LIST_POST_NOTE'),
            plugins: { 'hapi-swagger': { order: 6 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postTypeIdentifier,
                query: postListRequest
            },
            response: {
                status: {
                    200: postListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'GET',
        path: '/post/list',
        handler: postHandler.listByTags,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('LIST_POST_DESCRIPTION'),
            notes: I18N.t('LIST_POST_NOTE'),
            plugins: { 'hapi-swagger': { order: 7 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'user', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: postTagsListRequest
            },
            response: {
                status: {
                    200: postPublicListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'GET',
        path: '/post/{postType}/listAll',
        handler: postHandler.listAll,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('LIST_ALL_POST_DESCRIPTION'),
            notes: I18N.t('LIST_ALL_POST_NOTE'),
            plugins: { 'hapi-swagger': { order: 8 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'user', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postTypeIdentifier,
                query: postListAllRequest
            },
            response: {
                status: {
                    200: postListAllResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'GET',
        path: '/post/{postType}/{id}/listRevisions',
        handler: postHandler.listRevisions,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('LIST_POST_REVISIONS_DESCRIPTION'),
            notes: I18N.t('LIST_POST_REVISIONS_NOTE'),
            plugins: { 'hapi-swagger': { order: 9 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postIdentifier,
                query: postListRequest
            },
            response: {
                status: {
                    200: postListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'POST',
        path: '/post/{postType}/{id}/restore',
        handler: postHandler.restoreRevision,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('RESTORE_POST_REVISION_DESCRIPTION'),
            notes: I18N.t('RESTORE_POST_REVISION_NOTE'),
            plugins: { 'hapi-swagger': { order: 10 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postIdentifier
            },
            response: {
                status: {
                    200: postResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'PATCH',
        path: '/post/{postType}/{id}/sortOrder',
        handler: postHandler.setSortOrder,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('POST_SORT_ORDER_DESCRIPTION'),
            notes: I18N.t('POST_SORT_ORDER_NOTE'),
            plugins: { 'hapi-swagger': { order: 10 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postIdentifier,
                payload: postSortOrderRequest
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'PATCH',
        path: '/post/{postType}/{id}/status',
        handler: postHandler.updateStatus,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('POST_STATUS_UPDATE_DESCRIPTION'),
            notes: I18N.t('POST_STATUS_UPDATE_NOTE'),
            plugins: { 'hapi-swagger': { order: 11 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'managePost'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postIdentifier,
                payload: postStatusRequest
            },
            response: {
                status: {
                    200: postResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/{postType}/post/{id}',
        handler: postHandler.publicGetById,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('GET_POST_BY_ID_DESCRIPTION'),
            notes: I18N.t('GET_POST_BY_ID_NOTE'),
            plugins: { 'hapi-swagger': { order: 12 } },
            auth: { strategies: ['jwt'], scope: ['admin'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postIdentifier
            },
            response: {
                status: {
                    200: postPublicResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/post/{id}',
        handler: postHandler.publicGetById,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('GET_POST_BY_ID_DESCRIPTION'),
            notes: I18N.t('GET_POST_BY_ID_NOTE'),
            plugins: { 'hapi-swagger': { order: 13 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'user'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: postOnlyIdentifier
            },
            response: {
                status: {
                    200: postPublicResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/post/public/{postType}/list',
        handler: postHandler.publicList,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('LIST_PUBLIC_POST_DESCRIPTION'),
            notes: I18N.t('LIST_PUBLIC_POST_NOTE'),
            plugins: { 'hapi-swagger': { order: 14 } },
            auth: { strategies: ['jwt'], mode: 'optional' },
            validate: {
                headers: Common.routeHeaders("optionalauthorized"),
                options: options,
                failAction: Common.failover,
                params: postTypeIdentifier,
                query: postPublicListRequest
            },
            response: {
                status: {
                    200: postPublicListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    },
    {
        method: 'GET',
        path: '/post/public/{code}',
        handler: postHandler.getPublicPostByCode,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('GET_PUBLIC_POST_BY_ID_DESCRIPTION'),
            notes: I18N.t('GET_PUBLIC_POST_BY_ID_NOTE'),
            plugins: { 'hapi-swagger': { order: 15 } },
            auth: { strategies: ['jwt'], mode: 'optional' },
            validate: {
                headers: Common.routeHeaders("optionalauthorized"),
                options: options,
                failAction: Common.failover,
                params: postOnlyCodeIdentifier
            },
            response: {
                status: {
                    200: postPublicDetailResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/post/public/page/list',
        handler: postHandler.listPublicPages,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('LIST_PUBLIC_PAGES_DESCRIPTION') || 'List public pages',
            notes: I18N.t('LIST_PUBLIC_PAGES_NOTE') || 'Returns a list of public pages',
            plugins: { 'hapi-swagger': { order: 15 } },
            auth: { strategies: ['jwt'], mode: 'optional' },
            validate: {
                headers: Common.routeHeaders("optionalauthorized"),
                options: options,
                failAction: Common.failover,
                query: postListRequest
            },
            response: {
                status: {
                    200: postPublicPageListResponse,
                    400: error400,
                    500: error500
                }
            }
        },
    },
    {
        method: 'GET',
        path: '/post/public/page/{code}',
        handler: postHandler.getPublicPageByCode,
        options: {
            tags: ['api', 'Post'],
            description: I18N.t('GET_PUBLIC_PAGE_BY_CODE_DESCRIPTION') || 'Get unrestricted public page post by code',
            notes: I18N.t('GET_PUBLIC_PAGE_BY_CODE_NOTE') || 'Returns unrestricted full post content without comments',
            plugins: { 'hapi-swagger': { order: 16 } },
            auth: { strategies: ['jwt'], mode: 'optional' },
            validate: {
                headers: Common.routeHeaders("optionalauthorized"),
                options: options,
                failAction: Common.failover,
                params: postOnlyCodeIdentifier
            },
            response: {
                status: {
                    200: postPublicDetailResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            }
        },
    }
]

export default routes