import {
  AbstractAuthModuleProvider,
  MedusaError,
} from "@medusajs/framework/utils"
import {
  AuthenticationInput,
  AuthenticationResponse,
  AuthIdentityProviderService,
  Logger,
} from "@medusajs/framework/types"

type InjectedDependencies = {
  logger: Logger
}

interface CustomAuthConfig {
  apiKey: string
  apiSecret: string
}

export class CustomAuthService extends AbstractAuthModuleProvider {
  static identifier = "custom-auth"
  static DISPLAY_NAME = "Custom Authentication"

  protected config_: CustomAuthConfig
  protected logger_: Logger

  static validateOptions(options: CustomAuthConfig) {
    if (!options.apiKey) {
      throw new Error("API key is required")
    }
    if (!options.apiSecret) {
      throw new Error("API secret is required")
    }
  }

  constructor(
    { logger }: InjectedDependencies,
    options: CustomAuthConfig
  ) {
    // @ts-ignore
    super(...arguments)
    this.config_ = options
    this.logger_ = logger
  }

  async authenticate(
    input: AuthenticationInput,
    authIdentityService: AuthIdentityProviderService
  ): Promise<AuthenticationResponse> {
    const { email, token } = input.body ?? {}

    if (!email || !token) {
      return {
        success: false,
        error: "Email and token are required",
      }
    }

    try {
      // Validate token with your auth service
      const userData = await this.validateToken(token)

      // Get or create auth identity
      let authIdentity
      try {
        authIdentity = await authIdentityService.retrieve({
          entity_id: userData.id,
        })
      } catch (error) {
        if (error.type === MedusaError.Types.NOT_FOUND) {
          authIdentity = await authIdentityService.create({
            entity_id: userData.id,
            user_metadata: {
              email: userData.email,
              name: userData.name,
            },
          })
        } else {
          throw error
        }
      }

      return {
        success: true,
        authIdentity,
      }
    } catch (error) {
      return {
        success: false,
        error: error.message,
      }
    }
  }

  async register(
    input: AuthenticationInput,
    authIdentityService: AuthIdentityProviderService
  ): Promise<AuthenticationResponse> {
    // Implement registration logic
    throw new MedusaError(
      MedusaError.Types.NOT_ALLOWED,
      "Registration not supported"
    )
  }

  private async validateToken(token: string) {
    // Validate token with your auth service
    // Return user data
  }
}

import { ModuleProvider, Modules } from "@medusajs/framework/utils"
import { CustomAuthService } from "./services/custom-auth"

export default ModuleProvider(Modules.AUTH, {
  services: [CustomAuthService],
})