import type {
    AuthAccessRequestItem,
    AuthAllowedClientItem,
    AuthApplicationPageItem,
    AuthAuthorizationPageItem,
    PagedListWarp,
    AuthTokenPageItem,
    AdminMfaPayload,
    AdminMfaVerificationResult,
} from "../models/AuthModels";
import { ApiHttpClient } from "./ApiHttpClient";

export interface PageQuery {
    page: number;
    limit: number;
}

export interface ApplicationQuery extends PageQuery {
    keyword?: string;
}

export interface ApplicationFormPayload {
    id?: string;
    clientId: string;
    clientSecret?: string;
    displayName: string;
    logo?: string;
    applicationType?: string;
    clientType: string;
    redirectUris: string[];
    postLogoutRedirectUri?: string;
    permissions: string[];
    mfa?: AdminMfaPayload;
}

export interface AuthorizationQuery extends PageQuery {
    applicationId?: string;
    status?: string;
    type?: string;
    keyword?: string;
}

export interface TokenQuery extends PageQuery {
    userId?: string;
    clientId?: string;
}

export interface AccessRequestQuery extends PageQuery {
    account?: string;
    clientId?: string;
}

export interface GrantQuery extends PageQuery {
    account?: string;
    appId?: string;
}

export class AdminApiService {
    private readonly http = new ApiHttpClient();

    applications(query: ApplicationQuery) {
        return this.getPage<AuthApplicationPageItem>("/api/admin/applications", query);
    }

    applicationDetail(id: string) {
        return this.http.get<AuthApplicationPageItem>(
            `/api/admin/applications/${encodeURIComponent(id)}`,
        );
    }

    createApplication(payload: ApplicationFormPayload) {
        return this.http.post<AdminMfaVerificationResult>(
            "/api/admin/applications",
            this.toApplicationBody(payload),
        );
    }

    updateApplication(payload: ApplicationFormPayload) {
        return this.http.put<AdminMfaVerificationResult>(
            `/api/admin/applications/${encodeURIComponent(payload.id ?? "")}`,
            this.toApplicationBody(payload),
        );
    }

    authorizations(query: AuthorizationQuery) {
        return this.getPage<AuthAuthorizationPageItem>("/api/admin/authorizations", query);
    }

    tokens(query: TokenQuery) {
        return this.getPage<AuthTokenPageItem>("/api/admin/tokens", query);
    }

    accessRequests(query: AccessRequestQuery) {
        return this.getPage<AuthAccessRequestItem>("/api/admin/access-requests", query);
    }

    grants(query: GrantQuery) {
        return this.getPage<AuthAllowedClientItem>("/api/admin/grants", query);
    }

    deleteApplication(id: string, mfa?: AdminMfaPayload) {
        return this.http.delete<AdminMfaVerificationResult>(
            `/api/admin/applications/${encodeURIComponent(id)}`,
            mfa ?? {},
        );
    }

    revokeAuthorization(item: AuthAuthorizationPageItem, mfa?: AdminMfaPayload) {
        return this.http.post<AdminMfaVerificationResult>("/api/admin/authorizations/revoke", {
            applicationId: item.applicationId,
            status: item.status ?? "",
            type: item.type ?? "",
            ...(mfa ?? {}),
        });
    }

    revokeTokenByUser(userId: string, mfa?: AdminMfaPayload) {
        return this.http.post<AdminMfaVerificationResult>("/api/admin/tokens/revoke-by-user", {
            userId,
            ...(mfa ?? {}),
        });
    }

    revokeTokenByClient(clientId: string, mfa?: AdminMfaPayload) {
        return this.http.post<AdminMfaVerificationResult>("/api/admin/tokens/revoke-by-client", {
            clientId,
            ...(mfa ?? {}),
        });
    }

    handleAccessRequest(id: string, status: number, remark: string) {
        return this.http.patch(`/api/admin/access-requests/${encodeURIComponent(id)}`, {
            status,
            remark,
        });
    }

    grantAllowedClient(account: string, appId: string) {
        return this.http.post("/api/admin/grants", { account, appId });
    }

    revokeAllowedClient(id: string) {
        return this.http.delete(`/api/admin/grants/${encodeURIComponent(id)}`);
    }

    private getPage<T>(url: string, query: object) {
        const requestUrl = `${url}?${this.toSearchParams(query).toString()}`;
        return this.http.get<PagedListWarp<T>>(requestUrl);
    }

    private toApplicationBody(payload: ApplicationFormPayload) {
        return {
            clientId: payload.clientId,
            clientSecret: payload.clientSecret,
            displayName: payload.displayName,
            logo: payload.logo,
            applicationType: payload.applicationType,
            clientType: payload.clientType,
            redirectUris: payload.redirectUris,
            postLogoutRedirectUri: payload.postLogoutRedirectUri,
            permissions: payload.permissions,
            ...(payload.mfa ?? {}),
        };
    }

    private toSearchParams(query: object) {
        const params = new URLSearchParams();
        for (const [key, value] of Object.entries(query)) {
            if (value === undefined || value === null || value === "") {
                continue;
            }
            params.append(key, String(value));
        }
        return params;
    }
}