import * as gracely from "gracely"
import * as isoly from "isoly"
import * as authly from "authly"
import { Connection } from "@payfunc/model-base"
import { Authorization as ModelAuthorization } from "../Authorization"
import { Operation } from "../Authorization/Operation"
import { Capture } from "../Capture"
import { Error } from "../Error"
import { Refund } from "../Refund"
import * as state from "../State"
interface Operations {
	cancel: () => Promise<gracely.Result>
	capture: (request: Capture.Creatable) => Promise<Capture | gracely.Error>
	refund: (request: Refund.Creatable) => Promise<Refund | gracely.Error>
}
export class Authorization {
	constructor(readonly connection: Connection) {}
	async create(
		request: ModelAuthorization.Creatable,
		method?: "POST" | "GET"
	): Promise<(ModelAuthorization & Operations) | gracely.Error> {
		const result = await this.connection.post<ModelAuthorization>(
			"authorization" + (method ? "?method=" + method : ""),
			request
		)
		return ModelAuthorization.is(result, false)
			? this.load(result)
			: gracely.Error.is(result)
			? result
			: Error.backendFailure("Failed to create authorization.")
	}
	async update(updates: Operation.Creatable[]): Promise<Operation[] | gracely.Error> {
		return await this.connection.patch<Operation[] | gracely.Error>("authorization/", updates)
	}
	async list(
		state: true,
		merchants?: string[],
		start?: isoly.Date,
		end?: isoly.Date
	): Promise<(state.Authorization | state.FailedAuthorization)[] | gracely.Error>
	async list(
		state: true,
		merchants?: string,
		start?: isoly.Date,
		end?: isoly.Date,
		limit?: number,
		continuation?: boolean
	): Promise<(state.Authorization | state.FailedAuthorization)[] | gracely.Error>
	async list(
		state?: false | undefined,
		merchants?: string[],
		start?: isoly.Date,
		end?: isoly.Date
	): Promise<ModelAuthorization[] | gracely.Error>
	async list(
		state?: false | undefined,
		merchants?: string,
		start?: isoly.Date,
		end?: isoly.Date,
		limit?: number,
		continuation?: boolean
	): Promise<ModelAuthorization[] | gracely.Error>
	async list(
		state = false,
		merchants?: string | string[],
		start?: isoly.Date,
		end?: isoly.Date,
		limit?: number,
		continuation?: boolean
	): Promise<ModelAuthorization[] | (state.Authorization | state.FailedAuthorization)[] | gracely.Error> {
		const queryList = state ? ["state=true"] : []
		start && queryList.push(`start=${start}`)
		end && queryList.push(`end=${end}`)
		merchants && queryList.push(`merchants=${merchants}`)
		limit && queryList.push(`limit=${limit}`)
		const query = queryList.join("&")
		return await this.connection.get<
			ModelAuthorization[] | (state.Authorization | state.FailedAuthorization)[] | gracely.Error
		>(
			"authorization" + (query ? "?" + query : ""),
			undefined,
			typeof merchants == "string" ? `authorization-` + merchants : undefined,
			continuation
		)
	}
	async get(authorization: authly.Identifier): Promise<ModelAuthorization | gracely.Error> {
		return this.connection.get<ModelAuthorization | gracely.Error>("authorization/" + authorization)
	}
	load(authorization: ModelAuthorization): ModelAuthorization & Operations
	load(authorization: string): { id: string } & Operations
	load(authorization: ModelAuthorization | string): (ModelAuthorization | { id: string }) & Operations
	load(authorization: ModelAuthorization | string): (ModelAuthorization | { id: string }) & Operations {
		const result = {
			...(typeof authorization == "string" ? { id: authorization } : authorization),
			cancel: (): Promise<gracely.Result> => this.connection.delete("authorization/" + result.id),
			capture: (capture: Capture.Creatable): Promise<Capture | gracely.Error> =>
				this.connection.post("authorization/" + result.id + "/capture", capture),
			refund: (refund: Refund.Creatable): Promise<Refund | gracely.Error> =>
				this.connection.post("authorization/" + result.id + "/refund", refund),
		}
		return result
	}
	static open(url: string, key: string): Authorization
	static open(url?: string, key?: string): Authorization | undefined
	static open(url?: string, key?: string): Authorization | undefined {
		const connection = Connection.open(url, key)
		return connection && new Authorization(connection)
	}
}