import * as gracely from "gracely"
import { Authorization } from "../Authorization"
import { convert as convertSummary } from "./conversion/convert"
import { convert as convertDetailed } from "./conversion/detailed/convert"
import { Master } from "./conversion/detailed/Master"
import { Master as SMaster } from "./conversion/Master"
import { Settlement } from "./Settlement"

export type Metabase = Partial<Record<Metabase.ColumnName, string | undefined>>
export namespace Metabase {
	export type ColumnName = typeof Metabase.columns[number]
	export const columns = <const>[
		"Settlement Id",
		"Merchant",
		"Operation",
		"Tx Date",
		"Clearing Date",
		"Tx Amount",
		"Tx Currency",
		"Gross Currency",
		"Authorization Id",
		"Authorization Number",
		"Card Iin",
		"Card Type",
		"Card Scheme",
		"Scheme Reference",
		"Issuer Country",
		"Currency",
		"Settlement Service",
		"Gross Amount",
		"Interchange",
		"Scheme Fee",
		"Intergiro Fee",
		"Total Fee",
		"Fee",
		"Net Amount",
		"Fx Rate",
		"Fxd Net Amount",
		"Payout Currency",
		"Transfer Date",
		"Arn",
		"Processor",
		"Reserve Release Date",
		"Reserve Amount",
		"Created",
		"Transactions",
		"Period From",
		"Period To",
		"Payout Date",
		"Payout Amount",
	]
	export function is(value: any | Metabase): value is Metabase {
		return (
			typeof value == "object" &&
			value &&
			Object.entries(value).every(
				([k, v]) => columns.includes(k as ColumnName) && (v == undefined || typeof v == "string")
			)
		)
	}

	export function requiredSummaryFields(input: Metabase[]): Metabase[] | gracely.Error {
		const required = <const>[
			"Settlement Id",
			"Merchant",
			"Period From",
			"Period To",
			"Gross Amount",
			"Intergiro Fee",
			"Net Amount",
			"Payout Amount",
			"Processor",
			"Scheme Fee",
			"Payout Date",
			"Created",
			"Interchange",
			"Transactions",
			"Currency",
			"Total Fee",
		]
		const errors: string[] = []
		return input.every(value => {
			let result = true
			for (const requiredKey of required) {
				if (!value[requiredKey]) {
					errors.push(requiredKey)
					result = false
				}
			}
			return result
		})
			? input
			: gracely.client.flawedContent({ type: "Settlement.Metabase", flaws: errors.map(e => ({ type: e })) })
	}

	export function requiredDetailFields(input: Metabase[]): Metabase[] | gracely.Error {
		const required = <const>[
			"Arn",
			"Settlement Id",
			"Merchant",
			"Authorization Id",
			"Authorization Number",
			"Card Iin",
			"Card Scheme",
			"Card Type",
			"Gross Amount",
			"Interchange",
			"Intergiro Fee",
			"Net Amount",
			"Processor",
			"Scheme Fee",
			"Scheme Reference",
			"Total Fee",
			"Tx Amount",
			"Tx Currency",
			"Tx Date",
			"Operation",
		]
		const errors: string[] = []
		return input.every(value => {
			let result = true
			for (const requiredKey of required) {
				if (!value[requiredKey] || (requiredKey == "Authorization Id" && value["Authorization Id"] == "Placeholder")) {
					errors.push(requiredKey)
					result = false
				}
			}
			return result
		})
			? input
			: gracely.client.flawedContent({ type: "Settlement.Metabase", flaws: errors.map(e => ({ type: e })) })
	}

	export function to(level: "settlement", settlements: Settlement[]): Metabase[] | gracely.Error
	export function to(
		level: "transaction",
		settlements: Settlement[],
		authorizations: Authorization[]
	): Metabase[] | gracely.Error

	export function to(
		level: "settlement" | "transaction",
		settlements: Settlement[],
		authorizations?: Authorization[]
	): Metabase[] | gracely.Error {
		return level == "transaction" && authorizations
			? requiredDetailFields(map(convertDetailed(settlements, authorizations, "master", true)))
			: requiredSummaryFields(map(convertSummary(settlements, "master", true)))
	}
	export function map(input: Master.Csv | SMaster.Csv): Metabase[] {
		const result: Metabase[] = []
		let newRow: Metabase | undefined
		for (const row of input.data) {
			newRow = {}
			for (const [column, value] of Object.entries(row))
				if (value != undefined) {
					const typedColumnName: typeof Master.header[number] = column as typeof Master.header[number]
					newRow[typedColumnName] = value
				}
			result.push(newRow)
		}
		return result
	}
}