import { ReqTypes, RequestBase } from "./RequestTypes";
import { ResponseBase, ResTypes } from "./ResponseTypes";

export namespace DcEndPoints {
  export type methods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
  export class EndPoint<T extends RequestBase, U extends ResponseBase> {
    constructor(
      router: string,
      endpoint: string,
      method: methods,
      request?: T
    ) {
      this._router = router;
      this._endpoint = endpoint;
      this._method = method;
      this._request = request;
    }
    private _request?: T;
    public get request(): T | undefined {
      return this._request;
    }
    public SetReqBody(value: T) {
      this._request = value;
    }

    private readonly _router: string;
    private readonly _endpoint: string;
    private readonly _method: methods;
    public get router(): string {
      return this._router;
    }
    public get endpoint(): string {
      return this._endpoint;
    }
    public get method(): methods {
      return this._method;
    }

    public get fullRoute(): string {
      return this.router + "/" + this.endpoint;
    }

    public get RouteWithParams(): string {
      if (this.method === "POST" || this.method === "PUT" || this.method === "PATCH")
        return this.fullRoute;
      let route = this.fullRoute;
      if (this.request) {
        const searchParams = new URLSearchParams();
        for (const key in this.request) {
          if (this.request.hasOwnProperty(key)) {
            searchParams.set(key, String(this.request[key]));
          }
        }
        route += "?" + searchParams.toString();
      }
      return route;
    }

    public get body(): T | undefined {

      if (this.method === "POST" || this.method === "PUT" || this.method === "PATCH") {
        return this._request;
      }
      return undefined;
    }

    public _doNotUse : U = {} as unknown as U;

  }
  export class DoesUserExist extends EndPoint<ReqTypes.DoesUserExistRequest, ResTypes.DoesUserExistResponse> {
    constructor(request?: ReqTypes.DoesUserExistRequest) {
      super("user", "exists", "GET", request);
    }
  }



  export class CreateChatBot extends EndPoint<ReqTypes.CreateChatBotRequest, ResTypes.CreateChatBotResponse> {
    constructor(request?: ReqTypes.CreateChatBotRequest) {
      super("chatbot", "create", "POST", request);
    }
  }

  export class EditChatBot extends EndPoint<ReqTypes.EditChatBotRequest, ResTypes.EditChatBotResponse> {
    constructor(request?: ReqTypes.EditChatBotRequest) {
      super("chatbot", "edit", "POST", request);
    }
  }

  export class QueryChatBot extends EndPoint<ReqTypes.QueryChatBotRequest, ResTypes.QueryChatBotResponse> {
    constructor(request?: ReqTypes.QueryChatBotRequest) {
      super("chatbot", "query", "POST", request);
    }
  }

  export class GetChatBots extends EndPoint<ReqTypes.GetChatBotsRequest, ResTypes.GetChatBotsResponse> {
    constructor(request?: ReqTypes.GetChatBotsRequest) {
      super("chatbots", "get", "POST", request);
    }
  }
  export class GetChatBot extends EndPoint<ReqTypes.GetChatbotRequest, ResTypes.GetChatbotResponse> {
    constructor(request?: ReqTypes.GetChatbotRequest) {
      super("chatbot", "get", "POST", request);
    }
  }

  export class InitChatBot extends EndPoint<ReqTypes.InitChatRequest, ResTypes.InitChatResponse> {
    constructor(request?: ReqTypes.InitChatRequest) {
      super("chatbot", "init", "POST", request);
    }
  }

  export class GetChatBotDocuments extends EndPoint<ReqTypes.GetChatBotDocumentsRequest, ResTypes.GetChatBotDocumentsResponse> {
    constructor(request?: ReqTypes.GetChatBotDocumentsRequest) {
      super("chatbot", "documents", "POST", request);
    }
  }

  export class GetChatBotForChat extends EndPoint<ReqTypes.GetChatBotForChatRequest, ResTypes.GetChatBotForChatResponse> {
    constructor(request?: ReqTypes.GetChatBotForChatRequest) {
      super("chatbot", "getById", "POST", request);
    }
  }

  export class DeleteChatBot extends EndPoint<ReqTypes.DeleteChatBotRequest, ResTypes.DeleteChatBotResponse> {
    constructor(request?: ReqTypes.DeleteChatBotRequest) {
      super("chatbot", "delete", "POST", request);
    }
  }

export class FavoriteChatBot extends EndPoint<ReqTypes.UpdateChatBotFavoriteStatusRequest, ResTypes.UpdateChatBotFavoriteStatusResponse> {
  constructor(request?: ReqTypes.UpdateChatBotFavoriteStatusRequest) {
      super("chatbot", "favorite", "POST", request);
    }
  }

  export class GetChatBotStatusAndId extends EndPoint<ReqTypes.GetChatBotIdAndStatusesForUserRequest, ResTypes.GetChatBotIdAndStatusesForUserResponse> {
    constructor(request?: ReqTypes.GetChatBotIdAndStatusesForUserRequest) {
      super("chatbot", "getIdAndStasuses", "POST", request);
    }
  }

  export class GetDocumentStatusAndId extends EndPoint<ReqTypes.GetDocumentIdAndStatusesForUserRequest, ResTypes.GetDocumentIdAndStatusesForUserResponse> {
    constructor(request?: ReqTypes.GetDocumentIdAndStatusesForUserRequest) {
      super("document", "getIdAndStasuses", "POST", request);
    }
  }

  export class GetChatBotVisibleUrl extends EndPoint<ReqTypes.GetChatBotVisibleUrlRequest, ResTypes.GetChatBotVisibleUrlResponse> {
    constructor(request?: ReqTypes.GetChatBotVisibleUrlRequest) {
      super("chatbot", "getVisibleUrl", "GET", request);
    }
  }
  export class GetUserInfo extends EndPoint<ReqTypes.GetUserInfoRequest, ResTypes.GetUserInfoResponse> {
    constructor(request?: ReqTypes.GetUserInfoRequest) {
      super("user", "getInfo", "POST", request);
    }
  }


  export class UpsertOrganizationUser extends EndPoint<ReqTypes.UpsertOrganizationUserRequest, ResTypes.UpsertOrganizationUserResponse> {
    constructor(request?: ReqTypes.UpsertOrganizationUserRequest) {
      super("user", "upsertOrganizationUser", "POST", request);
    }
  }

  export class SetOrganizationData extends EndPoint<ReqTypes.SetOrganizationDataRequest, ResTypes.SetOrganizationDataResponse> {
    constructor(request?: ReqTypes.SetOrganizationDataRequest) {
      super("organization", "setOrganizationData", "POST", request);
    }
  }
  
  export class GetOrganizationUsers extends EndPoint<ReqTypes.GetOrganizationUsersRequest, ResTypes.GetOrganizationUsersResponse> {
    constructor(request?: ReqTypes.GetOrganizationUsersRequest) {
      super("user", "getOrganizationUsers", "POST", request);
    }
  }

  export class CreateUserForExternalSignup extends EndPoint<ReqTypes.CreateUserForExternalSignupRequest, ResTypes.CreateUserForExternalSignupResponse> {
    constructor(request?: ReqTypes.CreateUserForExternalSignupRequest) {
      super("user", "createForExternalSignup", "POST", request);
    }
  }

  export class GetChatBotForEmbed extends EndPoint<ReqTypes.GetChatBotForEmbedRequest, ResTypes.GetChatBotForEmbedResponse> {
    constructor(request?: ReqTypes.GetChatBotForEmbedRequest) {
      super("chatbot", "getForEmbed", "POST", request);
    }
  }

  export class AddDocuments extends EndPoint<ReqTypes.AddDocumentsRequest, ResTypes.AddDocumentsResponse> {
    constructor(request?: ReqTypes.AddDocumentsRequest) {
      super("documents", "addDocuments", "POST", request);
    }
  }

  export class DeleteDocuments extends EndPoint<ReqTypes.DeleteDocumentsRequest, ResTypes.DeleteDocumentsResponse> {
    constructor(request?: ReqTypes.DeleteDocumentsRequest) {
      super("documents", "deleteDocuments", "POST", request);
    }
  }

  export class GetUserDocuments extends EndPoint<ReqTypes.GetUserDocumentsRequest, ResTypes.GetUserDocumentsResponse> {
    constructor(request?: ReqTypes.GetUserDocumentsRequest) {
      super("documents", "getDocuments", "POST", request);
    }
  }
  
  export class RenameDocuments extends EndPoint<ReqTypes.RenameDocumentsRequest, ResTypes.RenameDocumentsResponse> {
    constructor(request?: ReqTypes.RenameDocumentsRequest) {
      super("documents", "renameDocuments", "POST", request);
    }
  }

  export class DownloadDocument extends EndPoint<ReqTypes.DownloadDocumentRequest, ResTypes.DownloadDocumentResponse> {
    constructor(request?: ReqTypes.DownloadDocumentRequest) {
      super("documents", "downloadDocument", "POST", request);
    }
  }

  export class SigninWithPassword extends EndPoint<ReqTypes.SigninWithPasswordRequest, ResTypes.SigninWithPasswordResponse> {
    constructor(request?: ReqTypes.SigninWithPasswordRequest) {
      super("user", "signinWithPassword", "POST", request);
    }
  }

    export class GetPlans extends EndPoint<ReqTypes.GetPlansRequest, ResTypes.GetPlansResponse> {
    constructor(request?: ReqTypes.GetPlansRequest) {
      super("plan", "getPlans", "POST", request);
    }
  }

  export class GetPaymentProviders extends EndPoint<ReqTypes.GetPaymentProvidersRequest, ResTypes.GetPaymentProvidersResponse> {
    constructor(request?: ReqTypes.GetPaymentProvidersRequest) {
      super("plan", "getPaymentProviders", "GET", request);
    }
  }

  export class GetAccountUsages extends EndPoint<ReqTypes.GetAccountUsagesRequest, ResTypes.GetAccountUsagesResponse> {
    constructor(request?: ReqTypes.GetAccountUsagesRequest) {
      super("plan", "getAccountPlan", "POST", request);
    }
  }

  export class UpdatePlan extends EndPoint<ReqTypes.UpdatePlanRequest, ResTypes.UpdatePlanResponse> {
    constructor(request?: ReqTypes.UpdatePlanRequest) {
      super("plan", "updatePlan", "POST", request);
    }
  }

  export class GetBillingPortalUrl extends EndPoint<ReqTypes.GetBillingPortalUrlRequest, ResTypes.GetBillingPortalUrlResponse> {
    constructor(request?: ReqTypes.GetBillingPortalUrlRequest) {
      super("plan", "getBillingPortalUrl", "POST", request);
    }
  }
  
  export class CancelSubscription extends EndPoint<ReqTypes.CancelSubscriptionRequest, ResTypes.CancelSubscriptionResponse> {
    constructor(request?: ReqTypes.CancelSubscriptionRequest) {
      super("plan", "cancelSubscription", "POST", request);
    }
  }
  
  export class SetCompletedOnBoarding extends EndPoint<ReqTypes.SetCompletedOnBoardingRequest, ResTypes.SetCompletedOnBoardingResponse> {
    constructor(request?: ReqTypes.SetCompletedOnBoardingRequest) {
      super("user", "setCompletedOnBoarding", "POST", request);
    }
  }
  
  export class Signup extends EndPoint<ReqTypes.SignupRequest, ResTypes.SignupResponse> {
    constructor(request?: ReqTypes.SignupRequest) {
      super("user", "signup", "POST", request);
    }
  }
  
    export class SendResetPasswordEmail extends EndPoint<ReqTypes.SendResetPasswordEmailRequest, ResTypes.SendResetPasswordEmailResponse> {
    constructor(request?: ReqTypes.SendResetPasswordEmailRequest) {
      super("user", "sendResetPasswordEmail", "POST", request);
    }
  }
  

  export class IsPasswordResetTokenValid extends EndPoint<ReqTypes.IsPasswordResetTokenValidRequest, ResTypes.IsPasswordResetTokenValidResponse> {
    constructor(request?: ReqTypes.IsPasswordResetTokenValidRequest) {
      super("user", "isPasswordResetTokenValid", "POST", request);
    }
  }

  export class ResetPassword extends EndPoint<ReqTypes.ResetPasswordRequest, ResTypes.ResetPasswordResponse> {
    constructor(request?: ReqTypes.ResetPasswordRequest) {
      super("user", "resetPassword", "POST", request);
    }
  }
  
  export class RateAnswer extends EndPoint<ReqTypes.RateAnswerRequest, ResTypes.RateAnswerResponse> {
    constructor(request?: ReqTypes.RateAnswerRequest) {
      super("chatbot", "rateAnswer", "POST", request);
    }
  }
  
  export class GetChatbotAnalytics extends EndPoint<ReqTypes.GetChatbotAnalyticsRequest, ResTypes.GetChatbotAnalyticsResponse> {
    constructor(request?: ReqTypes.GetChatbotAnalyticsRequest) {
      super("analytics", "getChatbotAnalytics", "GET", request);
    }
  }
  export class GetChatBotSessions extends EndPoint<ReqTypes.GetChatbotSessionsRequest, ResTypes.GetChatbotSessionsResponse> {
    constructor(request?: ReqTypes.GetChatbotSessionsRequest) {
      super("chatbot", "getSessions", "GET", request);
    }
  }
  export class UpsertAzureOpenAiCredentials extends EndPoint<ReqTypes.UpsertAzureOpenAiCredentialsRequest, ResTypes.UpsertAzureOpenAiCredentialsResponse> {
    constructor(request?: ReqTypes.UpsertAzureOpenAiCredentialsRequest) {
      super("integrations", "upsert", "POST", request);
    }
  }

  export class GetAzureOpenAiCredentials extends EndPoint<ReqTypes.GetAzureOpenAiCredentialsRequest, ResTypes.GetAzureOpenAiCredentialsResponse> {
    constructor(request?: ReqTypes.GetAzureOpenAiCredentialsRequest) {
      super("integrations", "get", "POST", request);
    }
  }

  export class EditChatBotShareOptions extends EndPoint<ReqTypes.EditChatBotShareOptionsRequest, ResTypes.EditChatBotShareOptionsResponse> {
    constructor(request?: ReqTypes.EditChatBotShareOptionsRequest) {
      super("chatbot", "editShareOptions", "POST", request);
    }
  }


  export class EditChatbotLimitsOptions extends EndPoint<ReqTypes.EditChatbotLimitsOptionsRequest, ResTypes.EditChatbotLimitsOptionsResponse> {
    constructor(request?: ReqTypes.EditChatbotLimitsOptionsRequest) {
      super("chatbot", "editLimitsOptions", "POST", request);
    }
  }

  export class EditChatbotVisible extends EndPoint<ReqTypes.EditChatbotVisibleUrlRequest, ResTypes.EditChatbotVisibleResponse> {
    constructor(request?: ReqTypes.EditChatbotVisibleUrlRequest) {
      super("chatbot", "editVisibleUrl", "POST", request);
    }
  }
  export class EditChatbotWidgetUrl extends EndPoint<ReqTypes.EditChatbotWidgetUrlRequest, ResTypes.EditChatbotWidgetUrlResponse> {
    constructor(request?: ReqTypes.EditChatbotWidgetUrlRequest) {
      super("chatbot", "editWidgetUrl", "POST", request);
    }
  }

  export class DuplicateChatbot extends EndPoint<ReqTypes.DuplicateChatbotRequest, ResTypes.DuplicateChatbotResponse> {
    constructor(request?: ReqTypes.DuplicateChatbotRequest) {
      super("chatbot", "duplicate", "POST", request);
    }
  }

  export class EnforceDataResidency extends EndPoint<ReqTypes.EnforceDataResidencyRequest, ResTypes.EnforceDataResidencyResponse> {
    constructor(request?: ReqTypes.EnforceDataResidencyRequest) {
      super("organization", "enforceDataResidency", "POST", request);
    }
  }

  export class GetOrganizationCssByChatBotId extends EndPoint<ReqTypes.GetOrganizationCssByChatBotIdRequest, ResTypes.GetOrganizationCssByChatBotIdResponse> {
    constructor(request?: ReqTypes.GetOrganizationCssByChatBotIdRequest) {
      super("chatbot", "getOrganizationCssByChatBotId", "POST", request);
    }
  }

  export class UpsertGoogleDriveIntegration extends EndPoint<ReqTypes.UpsertGoogleDriveIntegrationRequest, ResTypes.UpsertGoogleDriveIntegrationResponse> {
    constructor(request?: ReqTypes.UpsertGoogleDriveIntegrationRequest) {
      super("integrations", "upsertGoogleDrive", "POST", request);
    }
  }

  export class RemoveGoogleDriveIntegration extends EndPoint<ReqTypes.RemoveGoogleDriveIntegrationRequest, ResTypes.RemoveGoogleDriveIntegrationResponse> {
    constructor(request?: ReqTypes.RemoveGoogleDriveIntegrationRequest) {
      super("integrations", "removeGoogleDrive", "POST", request);
    }
  }

  export class SetCTAUsedInSession extends EndPoint<ReqTypes.SetCTAUsedInSessionRequest, ResTypes.SetCTAUsedInSessionResponse> {
    constructor(request?: ReqTypes.SetCTAUsedInSessionRequest) {
      super("session", "setCTAUsed", "POST", request);
    }
  }

  export class SendDeleteAccountEmail extends EndPoint<ReqTypes.SendDeleteAccountEmailRequest, ResTypes.SendDeleteAccountEmailResponse> {
    constructor(request?: ReqTypes.SendDeleteAccountEmailRequest) {
      super("user", "sendDeleteAccountEmail", "POST", request);
    }
  }

  export class SynchronizeGoogleDriveFolders extends EndPoint<ReqTypes.SynchronizeGoogleDriveFoldersRequest, ResTypes.SynchronizeGoogleDriveFoldersResponse> {
    constructor(request?: ReqTypes.SynchronizeGoogleDriveFoldersRequest) {
      super("integrations", "synchronizeGoogleDriveFolders", "POST", request);
    }
  }

  export class ModifyChatSessionContext extends EndPoint<ReqTypes.ModifyChatSessionContextRequest, ResTypes.ModifyChatSessionContextResponse> {
    constructor(request?: ReqTypes.ModifyChatSessionContextRequest) {
      super("session", "modifyContext", "POST", request);
    }
  }

  export class GetCompletionModels extends EndPoint<ReqTypes.GetCompletionModelsRequest, ResTypes.GetCompletionModelsResponse> {
    constructor(request?: ReqTypes.GetCompletionModelsRequest) {
      super("model", "getInfo", "POST", request);
    }
  }

  export class GenerateApiKey extends EndPoint<ReqTypes.GenerateApiKeyRequest, ResTypes.GenerateApiKeyResponse> {
    constructor(request?: ReqTypes.GenerateApiKeyRequest) {
      super("apiKey", "generate", "GET", request);
    }
  }
  export class RevokeApiKey extends EndPoint<ReqTypes.RevokeApiKeyRequest, ResTypes.RevokeApiKeyResponse> {
    constructor(request?: ReqTypes.RevokeApiKeyRequest) {
      super("apiKey", "revoke", "DELETE", request);
    }
  }

  export class GetMaskedApiKey extends EndPoint<ReqTypes.GetMaskedApiKeyRequest, ResTypes.GetMaskedApiKeyResponse> {
    constructor(request?: ReqTypes.GetMaskedApiKeyRequest) {
      super("apiKey", "getMasked", "GET", request);
    }
  }


  export class GetChatBotAndSessionBySessionId extends EndPoint<ReqTypes.GetChatBotAndSessionBySessionIdRequest, ResTypes.GetChatBotAndSessionBySessionIdResponse> {
    constructor(request?: ReqTypes.GetChatBotAndSessionBySessionIdRequest) {
      super("session", "getChatbotAndSession", "GET", request);
    }
  }

  export class GenerateAnalyticsReport extends EndPoint<ReqTypes.GenerateAnalyticsReportRequest, ResTypes.GenerateAnalyticsReportResponse> {
    constructor(request?: ReqTypes.GenerateAnalyticsReportRequest) {
      super("analytics", "generateReport", "POST", request);
    }
  }

  export class ListAnalyticsReports extends EndPoint<ReqTypes.ListAnalyticsReportsRequest, ResTypes.ListAnalyticsReportsResponse> {
    constructor(request?: ReqTypes.ListAnalyticsReportsRequest) {
      super("analytics", "listReports", "GET", request);
    }
  }

  export class GetAnalyticsReport extends EndPoint<ReqTypes.GetAnalyticsReportRequest, ResTypes.GetAnalyticsReportResponse> {
    constructor(request?: ReqTypes.GetAnalyticsReportRequest) {
      super("analytics", "getReport", "GET", request);
    }
  }

  export class GetChatBotPermissions extends EndPoint<ReqTypes.GetChatBotPermissionsRequest, ResTypes.GetChatBotPermissionsResponse> {
    constructor(request?: ReqTypes.GetChatBotPermissionsRequest) {
        super("chatbot", "permissions/get", "POST", request);
    }
  }

  export class UpdateChatBotPermissions extends EndPoint<ReqTypes.UpdateChatBotPermissionsRequest, ResTypes.UpdateChatBotPermissionsResponse> {
      constructor(request?: ReqTypes.UpdateChatBotPermissionsRequest) {
          super("chatbot", "permissions/update", "POST", request);
    }
  }

  export class GetOverview extends EndPoint<ReqTypes.GetOverviewRequest, ResTypes.GetOverviewResponse> {
    constructor(request?: ReqTypes.GetOverviewRequest) {
      super("analytics", "getOverview", "GET", request);
    }
  }
  
  export class GetTestimonialSubmissions extends EndPoint<ReqTypes.GetTestimonialSubmissionsRequest, ResTypes.GetTestimonialSubmissionsResponse> {
    constructor(request?: ReqTypes.GetTestimonialSubmissionsRequest) {
      super("user", "getTestimonialSubmissions", "POST", request);
    }
  }
  
  export class CreateTestimonialSubmission extends EndPoint<ReqTypes.CreateTestimonialSubmissionRequest, ResTypes.CreateTestimonialSubmissionResponse> {
    constructor(request?: ReqTypes.CreateTestimonialSubmissionRequest) {
      super("user", "createTestimonialSubmission", "POST", request);
    }
  }
}