import { ServerRoute } from '@hapi/hapi'
import { CampaignHandler } from '../handlers/campaign.handler'
import { options } from "../validators/global.validator.schema"
import { Common } from "../../utils/common"
import {
    campaignResponse,
    campaignRequest,
    campaignIdentifier,
    campaignStringIdentifier,
    campaignListRequest,
    campaignListRevisionRequest,
    campaignListResponse,
    campaignListAllRequest,
    campaignListAllResponse,
    campaignTypeIdentifier,
    campaignTreeResponse,
    campaignSortOrderRequest,
    campaignTypeCodeIdentifier,
    campaignStatusRequest,
    campaignSortIdentityIdentifier,
    campaignUserListRequest,
    campaignReportRequest,
    campaignLogRequest,
    campaignReportResponse
} from "../validators/campaign.validator"
const campaignHandler = new CampaignHandler();
import { I18N } from '../../utils/i18n';
import { error400, error401, error403, error404, error500, confirmationOnly } from "../validators/global.validator.schema"
const routes: ServerRoute[] = [
    {
        method: 'POST',
        path: '/campaign',
        handler: campaignHandler.create,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CREATE_CAMPAIGN_DESCRIPTION'),
            notes: I18N.t('CREATE_CAMPAIGN_NOTE'),
            plugins: { 'hapi-swagger': { order: 1 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: campaignRequest,
            },
            response: {
                status: {
                    200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/{id}',
        handler: campaignHandler.getById,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('GET_CAMPAIGN_BY_ID_DESCRIPTION'),
            notes: I18N.t('GET_CAMPAIGN_BY_ID_NOTE'),
            plugins: { 'hapi-swagger': { order: 2 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignIdentifier
            },
            response: {
                status: {
                    200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/{code}/byCode',
        handler: campaignHandler.getByCode,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('GET_CAMPAIGN_BY_CODE_DESCRIPTION'),
            notes: I18N.t('GET_CAMPAIGN_BY_CODE_NOTE'),
            plugins: { 'hapi-swagger': { order: 3 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignStringIdentifier
            },
            response: {
                status: {
                    200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'PATCH',
        path: '/campaign/{id}',
        handler: campaignHandler.update,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('UPDATE_CAMPAIGN_DESCRIPTION'),
            notes: I18N.t('UPDATE_CAMPAIGN_NOTE'),
            plugins: { 'hapi-swagger': { order: 4 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: campaignRequest,
                params: campaignIdentifier
            },
            response: {
                status: {
                    200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'DELETE',
        path: '/campaign/{id}',
        handler: campaignHandler.delete,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('DELETE_CAMPAIGN_DESCRIPTION'),
            notes: I18N.t('DELETE_CAMPAIGN_NOTE'),
            plugins: { 'hapi-swagger': { order: 5 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignSortIdentityIdentifier,
            },
            response: {
                status: {
                    200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/list',
        handler: campaignHandler.list,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('LIST_CAMPAIGN_DESCRIPTION'),
            notes: I18N.t('LIST_CAMPAIGN_NOTE'),
            plugins: { 'hapi-swagger': { order: 6 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: campaignListRequest
            },
            response: {
                status: {
                    200: campaignListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/listAll',
        handler: campaignHandler.listAll,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('LIST_ALL_CAMPAIGN_DESCRIPTION'),
            notes: I18N.t('LIST_ALL_CAMPAIGN_NOTE'),
            plugins: { 'hapi-swagger': { order: 7 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: campaignListAllRequest
            },
            response: {
                status: {
                    200: campaignListAllResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/{id}/listRevisions',
        handler: campaignHandler.listRevisions,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('LIST_CAMPAIGN_REVISIONS_DESCRIPTION'),
            notes: I18N.t('LIST_CAMPAIGN_REVISIONS_NOTE'),
            plugins: { 'hapi-swagger': { order: 8 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignIdentifier,
                query: campaignListRevisionRequest
            },
            response: {
                status: {
                    200: campaignListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'POST',
        path: '/campaign/{id}/restoreRevision',
        handler: campaignHandler.restoreRevision,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('LIST_CAMPAIGN_REVISIONS_DESCRIPTION'),
            notes: I18N.t('LIST_CAMPAIGN_REVISIONS_NOTE'),
            plugins: { 'hapi-swagger': { order: 9 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignIdentifier
            },
            response: {
                status: {
                    200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'PATCH',
        path: '/campaign/{id}/sortOrder',
        handler: campaignHandler.setSortOrder,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CAMPAIGN_SORT_ORDER_DESCRIPTION'),
            notes: I18N.t('CAMPAIGN_SORT_ORDER_NOTE'),
            plugins: { 'hapi-swagger': { order: 10 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignSortIdentityIdentifier,
                payload: campaignSortOrderRequest
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'PATCH',
        path: '/campaign/{id}/status',
        handler: campaignHandler.updateStatus,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CAMPAIGN_STATUS_UPDATE_DESCRIPTION'),
            notes: I18N.t('CAMPAIGN_STATUS_UPDATE_NOTE'),
            plugins: { 'hapi-swagger': { order: 11 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignIdentifier,
                payload: campaignStatusRequest
            },
            response: {
                status: {
                    200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'POST',
        path: '/campaign/assign-users',
        handler: campaignHandler.addUsersToCampaign,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CREATE_CAMPAIGN_DESCRIPTION'),
            notes: I18N.t('CREATE_CAMPAIGN_NOTE'),
            plugins: { 'hapi-swagger': { order: 12 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: campaignIdentifier,
            },
            response: {
                status: {
                    // 200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/users',
        handler: campaignHandler.listCampaignUsers,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CREATE_CAMPAIGN_DESCRIPTION'),
            notes: I18N.t('CREATE_CAMPAIGN_NOTE'),
            plugins: { 'hapi-swagger': { order: 14 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: campaignUserListRequest,
            },
            response: {
                status: {
                    // 200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/{id}/report',
        handler: campaignHandler.generateCampaignReport,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CREATE_CAMPAIGN_REPORT_DESCRIPTION'),
            notes: I18N.t('CREATE_CAMPAIGN_REPORT_NOTE'),
            plugins: { 'hapi-swagger': { order: 14 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignIdentifier,
                query: campaignReportRequest,
            },
            response: {
                status: {
                    200: campaignReportResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'GET',
        path: '/campaign/{id}/logs',
        handler: campaignHandler.getCampaignLogs,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CREATE_CAMPAIGN_LOG_DESCRIPTION'),
            notes: I18N.t('CREATE_CAMPAIGN_LOG_NOTE'),
            plugins: { 'hapi-swagger': { order: 14 } },
            auth: { strategies: ['jwt'], scope: ['admin', 'manageCampaingn'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: campaignIdentifier,
                query: campaignLogRequest,
            },
            response: {
                status: {
                    // 200: campaignResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }

            }
        },
    },
    {
        method: 'POST',
        path: '/campaign/webhook/whatsapp',
        handler: campaignHandler.campaignWhatsappWebhook,
        options: {
            tags: ['api', 'Campaign'],
            description: I18N.t('CREATE_CAMPAIGN_LOG_DESCRIPTION'),
            notes: I18N.t('CREATE_CAMPAIGN_LOG_NOTE'),
            plugins: { 'hapi-swagger': { order: 14 } },
            auth: false,
            validate: {
                headers: Common.routeHeaders(),
                options: options,
                failAction: Common.failover
            }
        },
    },
]

export default routes