import { BaseAdapterEntityDocument } from "@/common/base.adapter.entity";
import { Injectable } from "@nestjs/common";
import { Model } from "mongoose";
import { Adapter, AdapterPayload } from "oidc-provider";

@Injectable()
export class CustomAdapter implements Adapter {
  private name: string;
  private model: Model<BaseAdapterEntityDocument>;

  constructor(name: string, model: Model<BaseAdapterEntityDocument>) {
    this.name = name;
    this.model = model;
  }

  async upsert(id: string, payload: AdapterPayload, expiresIn: number): Promise<undefined | void> {
    try {
      let expiresAt: Date;
      if (expiresIn) {
        expiresAt = new Date(Date.now() + expiresIn * 1000);
      }
      if (this.name.toLocaleLowerCase() === "client") {
        //
      }
      await this.model.updateOne(
        { _id: id },
        { $set: { payload, ...(expiresAt ? { expiresAt } : undefined) } },
        { upsert: true }
      );
      return;
    } catch (e) {
      console.error(`[ADAPTER] (upsert) ${e}`);
    }
  }

  async find(id: string): Promise<AdapterPayload | undefined | void> {
    try {
      const _result = await this.model.findOne<BaseAdapterEntityDocument>({ _id: id }, { payload: 1 });
      if (!_result) return undefined;
      return _result.payload;
    } catch (e) {
      console.error(`[ADAPTER] (find) ${JSON.stringify(e)}`);
    }
  }

  async findByUserCode(userCode: string): Promise<AdapterPayload | undefined | void> {
    try {
      const _result = await this.model.findOne<BaseAdapterEntityDocument>(
        { "payload.userCode": userCode },
        { payload: 1 }
      );
      if (!_result) return undefined;
      return _result.payload;
    } catch (e) {
      console.error(`[ADAPTER] (findByUserCode) ${JSON.stringify(e)}`);
    }
  }

  async findByUid(uid: string): Promise<AdapterPayload | undefined | void> {
    try {
      const _result = await this.model.findOne<BaseAdapterEntityDocument>({ "payload.uid": uid }, { payload: 1 });
      if (!_result) return undefined;
      return _result.payload;
    } catch (e) {
      console.error(`[ADAPTER] (findByUid) ${JSON.stringify(e)}`);
    }
  }

  async consume(id: string): Promise<undefined | void> {
    try {
      await this.model.findOneAndUpdate({ _id: id }, { $set: { "payload.consumed": Math.floor(Date.now() / 1000) } });
    } catch (e) {
      console.error(`[ADAPTER] (consume) ${JSON.stringify(e)}`);
    }
  }

  async destroy(id: string): Promise<undefined | void> {
    try {
      await this.model.deleteOne({ _id: id });
    } catch (e) {
      console.error(`[ADAPTER] (destroy) ${JSON.stringify(e)}`);
    }
  }

  async revokeByGrantId(grantId: string): Promise<undefined | void> {
    try {
      await this.model.deleteMany({ "payload.grantId": grantId });
    } catch (e) {
      console.error(`[ADAPTER] (revokeByGrantId) ${JSON.stringify(e)}`);
    }
  }
}

import { OidcConfigs } from "@/config/oidc-config.service";

// import 생략...
@Global()
@Module({
  imports: [
    AccountModule,
    MongooseModule.forFeature([
      {
        name: AccessToken.name,
        schema: AccessTokenSchema,
        collection: "AccessToken"
      },
      // ...module import 생략...
      {
        name: Session.name,
        schema: SessionSchema,
        collection: "Session"
      }
    ])
  ],
  controllers: [OidcController],
  providers: [
    OidcConfigs,
    {
      provide: "OIDC_PROVIDER",
      inject: [ConfigService, OidcConfigs, AccountService],
      useFactory: async (configService: ConfigService, oidcConfigs: OidcConfigs, accountService: AccountService) => {
        const adapterFactory = oidcConfigs.createAdapterFactory();
        const provider = new Provider(`${configService.get("authURL")}:${configService.get("authPort")}`, {
          ...oidcConfigs.getConfigurations(),
          adapter: adapterFactory,
          findAccount: (ctx, sub, token) => accountService.findAccount(ctx, sub, token)
        });
        provider.proxy = true;
        provider.on("userinfo.error", (ctx, error) => {
          console.error(`🔥 [UserInfo error] : current-context = ${JSON.stringify(ctx)} ${JSON.stringify(error)}`);
        });
        return provider;
      }
    },
    OidcService
  ],
  exports: [OidcService, "OIDC_PROVIDER"]
})
export class OidcModule {}

  constructor(
    @InjectModel("AccessToken")
    private AccessTokenModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("AuthorizationCode")
    private AuthorizationCodeModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("BackchannelAuthenticationRequest")
    private BackchannelAuthenticationRequestModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("Client")
    private ClientModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("ClientCredentials")
    private ClientCredentialsModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("DeviceCode")
    private DeviceCodeModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("Grant")
    private GrantModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("Interaction")
    private InteractionModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("PushedAuthorizationRequest")
    private PushedAuthorizationRequestModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("RefreshToken")
    private RefreshTokenModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("RegistrationAccessToken")
    private RegistrationAccessTokenModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("ReplayDetection")
    private ReplayDetectionModel: Model<BaseAdapterEntityDocument>,
    @InjectModel("Session")
    private SessionModel: Model<BaseAdapterEntityDocument>,
  ) {}

  private getModel(name: string): Model<BaseAdapterEntityDocument> {
    switch (name) {
      case "AccessToken":
        return this.AccessTokenModel;
      case "AuthorizationCode":
        return this.AuthorizationCodeModel;
      case "BackchannelAuthenticationRequest":
        return this.BackchannelAuthenticationRequestModel;
      case "Client":
        return this.ClientModel;
      case "ClientCredentials":
        return this.ClientCredentialsModel;
      case "DeviceCode":
        return this.DeviceCodeModel;
      case "Grant":
        return this.GrantModel;
      case "Interaction":
        return this.InteractionModel;
      case "PushedAuthorizationRequest":
        return this.PushedAuthorizationRequestModel;
      case "RefreshToken":
        return this.RefreshTokenModel;
      case "RegistrationAccessToken":
        return this.RegistrationAccessTokenModel;
      case "ReplayDetection":
        return this.ReplayDetectionModel;
      case "Session":
        return this.SessionModel;
    }
  }

  createAdapterFactory(): AdapterFactory {
    return (moduleName: string): Adapter => {
      return new CustomAdapter(moduleName, this.getModel(moduleName));
    };
  }

// import 생략..

@Controller()
export class OidcController {
  private callback: (req: Request, res: Response) => void;

  constructor(
    @Inject("OIDC_PROVIDER")
    private readonly provider: Provider,
    private readonly moduleRef: ModuleRef
  ) {
    this.callback = provider.callback();
  }

  private getUrl(originalUrl: string) {
    let resultUrl = originalUrl;
    const appConfig = this.moduleRef["container"]!.applicationConfig;
    const globalPrefix = appConfig!.getGlobalPrefix();
    const versioning = appConfig!.getVersioning();

    // Remove global prefix
    if (globalPrefix) {
      resultUrl = resultUrl.replace(globalPrefix, "");
    }

    // Remove version
    if (versioning?.type === VersioningType.URI) {
      const version: string | symbol =
        Reflect.getMetadata(VERSION_METADATA, OidcController) ?? versioning.defaultVersion;

      if (version && version !== VERSION_NEUTRAL) {
        resultUrl = resultUrl.replace(/^\/*[^\/]+/, "");
      }
    }

    // Remove controller path
    const controllerPath = Reflect.getMetadata(PATH_METADATA, OidcController);
    resultUrl = resultUrl.replace(controllerPath, "");

    // Normalize
    return `/${resultUrl}`.replace(/^\/+/, "/");
  }

  @All("/*")
  public mountOidc(
    @Req()
    req: Request,
    @Res()
    res: Response
  ): void {
    req.url = this.getUrl(req.originalUrl);
    return this.callback(req, res);
  }
}