module arsd.ecommerce;

import std..string;
import std.conv;

static import std.date;
static import std.regex;

import arsd.curl;
import arsd.dom;

/*
	unit = "months" or "days"
*/

struct CreditCard {
	string number;
	int expirationMonth;
	int expirationYear;
	
	/// Filters out invalid characters
	@property string cardNumber() const {
		return std.regex.replace(
			cast(string) // the cast is necessary currently to work around a const bug in the stdlib
			number, std.regex.regex("[^0-9]", "g"), "");
	}

	bool validateChecksum() {
		string num = this.cardNumber;

		auto check = num[$-1] - '0';

		bool isTwo = true;

		int sum = check;
		for(int a = num.length - 2; a >= 0; a--) {
			int val = (num[a] - '0') * (isTwo ? 2 : 1);
			if(val >= 10)
				val -= 9;

			sum += val;
			isTwo = !isTwo;
		}

		return (sum % 10 == 0);
	}

	/// Returns the expiration date as a string authorize.net expects
	@property string expirationDate() const {
		int m = expirationMonth;
		int y = expirationYear;

		if(y < 1000)
			y += 2000;

		return format("%d-%02d", y, m);
	}
}

struct CustomerInfo {
	string firstName;
	string lastName;
	string emailAddress;

	string company;

	string phoneNumber;

	string address;
	string address2;
	string city;
	string state;
	string zip;
}

struct SubscriptionInfo {
	string name; /// name of the subscription, can be anything
	int durationLength; /// duration of the payment cycle. 30 means billed every 30 units - see durationUnit
	Unit durationUnit; /// the units of the duration length (payment cycle length). Can currently be days or months.
	Money amount; /// the amount to bill each cycle

	Money trialAmount;
	int trialOccurrences;

	enum Unit {
		days, months
	}

	@property string unitString() const {
		// the compiler can tell us the string of the enum...
		string[] unitNames;
		foreach(name; __traits(allMembers, SubscriptionInfo.Unit))
			unitNames ~= name;
			
		return unitNames[cast(int) durationUnit];
	}
}


struct Date {
	long timestamp; // a d_time value; unix time in milliseconds

	static Date now() {
		return Date(std.date.getUTCtime());
	}

	string toSlashDateString() const {
		auto day = std.date.dateFromTime(timestamp);
		auto year = std.date.yearFromTime(timestamp);
		auto month = std.date.monthFromTime(timestamp) + 1;

		return format("%02d/%02d/%04d", month, day, year);
	}

	string toDateString() const {
		auto day = std.date.dateFromTime(timestamp);
		auto year = std.date.yearFromTime(timestamp);
		auto month = std.date.monthFromTime(timestamp) + 1;

		return format("%d-%02d-%02d", year, month, day);
	}
}

class PaymentGatewayException : Exception {
	public this(string message, string file = __FILE__, size_t line = __LINE__) {
		super(message, file, line);
	}

	abstract GatewayFailure reason();
	abstract string reasonText();
}

class VirtualMerchantGatewayException : PaymentGatewayException {
	public this(int code, string message, string name, string[string] allVariables, string file = __FILE__, size_t line = __LINE__) {
		this.code = code;
		this.message = message;
		this.name = name;
		this.allVariables = allVariables;
		super(message, file, line);
	}

	int code;
	string message;
	string name;
	string[string] allVariables;

	override GatewayFailure reason() {
		switch(code) {
			// see page 202 of the document
			// BTW: 5033 is invalid recurring id
			case 5000: return GatewayFailure.invalidCreditCardNumber;
			case 5001: return GatewayFailure.creditCardExpired; // appears invalid
			case 6009: return GatewayFailure.creditCardExpired; // declined due to the expired card
			default:
				if(code > 6000 && code < 7000)
					return GatewayFailure.transactionDeclined;
				return GatewayFailure.unknown;
		}
	}

	override string reasonText() {
		return format("%s (code %s)", message, code);
	}
}

/// Thrown upon receiving a bad response from authorize.net (should never happen) or if the API returns an error.
class AuthorizeGatewayException : PaymentGatewayException {
	public this(string operation, string code, string message, string file = __FILE__, size_t line = __LINE__) {
		this.code = code;
		this.operation = operation;
		this.message = message;

		super(operation ~ " failed: " ~ message, file, line);
	}

	override GatewayFailure reason() {
		switch(code) {
			case "E00013": return GatewayFailure.creditCardExpired; // it has already expired
			case "E00018": return GatewayFailure.creditCardExpired; // it will expire before the subscription starts
			default: return GatewayFailure.unknown;
		}
	}

	override string reasonText() {
		return message;
	}

	string code;
	string operation;
	string message;
}

enum GatewayFailure {
	unknown,
	invalidCreditCardNumber,
	creditCardExpired,
	transactionDeclined,
}

struct VirtualMerchantCredentials {
	string merchantId;
	string userId;
	string pin;
}

void deleteVirtualMerchantSubscription(in VirtualMerchantCredentials credentials, in string subscriptionId) {
	string[string] args;
	args["ssl_transaction_type"] = "ccdeleterecurring";
	args["ssl_recurring_id"] = subscriptionId;
	assert(0, to!string(doVirtualMerchantRequest(credentials, args)));
}

void suspendVirtualMerchantSubscription(in VirtualMerchantCredentials credentials, in string subscriptionId) {
	string[string] args;
	args["ssl_transaction_type"] = "ccupdaterecurring";
	args["ssl_recurring_id"] = subscriptionId;
	args["ssl_billing_cycle"] = "SUSPENDED";
	assert(0, to!string(doVirtualMerchantRequest(credentials, args)));
}

void restoreVirtualMerchantSubscription(in VirtualMerchantCredentials credentials, in string subscriptionId, bool wasAnnual) {
	string[string] args;
	args["ssl_transaction_type"] = "ccupdaterecurring";
	args["ssl_recurring_id"] = subscriptionId;
	if(wasAnnual)
		args["ssl_billing_cycle"] = "ANNUALLY";
	else
		args["ssl_billing_cycle"] = "MONTHLY";
	assert(0, to!string(doVirtualMerchantRequest(credentials, args)));
}

void updateVirtualMerchantSubscription(in VirtualMerchantCredentials credentials, in string subscriptionId, in CustomerInfo customer, in CreditCard card) {
	string[string] args;
	args["ssl_transaction_type"] = "ccupdaterecurring";

	assert(subscriptionId.length);
	args["ssl_recurring_id"] = subscriptionId;

	args["ssl_show_form"] = "false";

	// card info
	args["ssl_card_number"] = card.cardNumber;
	args["ssl_exp_date"] = format("%02d%02d", card.expirationMonth, card.expirationYear);

	// name
	if(customer.firstName.length)
		args["ssl_first_name"] = customer.firstName;

	if(customer.lastName.length)
		args["ssl_last_name"] = customer.lastName;

	// billing address
	if(customer.address.length)
		args["ssl_avs_address"] = customer.address.length > 30 ? customer.address[0 .. 30] : customer.address;

	if(customer.city.length)
		args["ssl_city"] = customer.city;

	if(customer.state.length)
		args["ssl_state"] = customer.state;

	if(customer.zip.length)
		args["ssl_avs_zip"] = customer.zip;

	assert(0, to!string(doVirtualMerchantRequest(credentials, args)));
}

string createVirtualMerchantSubscription(in VirtualMerchantCredentials credentials, in SubscriptionInfo subscription, in Date startDate, in CustomerInfo customer, in CreditCard card) {

	string[string] args;
	args["ssl_transaction_type"] = "ccaddrecurring";
	args["ssl_show_form"] = "false";
	args["ssl_card_number"] = card.cardNumber;
	args["ssl_exp_date"] = format("%02d%02d", card.expirationMonth, card.expirationYear);
	args["ssl_amount"] = format("%s.%02d", subscription.amount.dollars, subscription.amount.cents);
	args["ssl_next_payment_date"] = startDate.toSlashDateString();

	final switch(subscription.durationUnit) {
		case SubscriptionInfo.Unit.days:
			args["ssl_billing_cycle"] = "MONTHLY"; // FIXME: use the right values from subscription info arg
			assert(subscription.durationLength == 30);
		break;
		case SubscriptionInfo.Unit.months:
			args["ssl_billing_cycle"] = "ANNUALLY"; // FIXME check the days too
			assert(subscription.durationLength == 12);
		break;
	}

	args["ssl_result_format"] = "ascii";

	args["ssl_first_name"] = customer.firstName;
	args["ssl_last_name"] = customer.lastName;

	args["ssl_avs_address"] = customer.address.length > 30 ? customer.address[0 .. 30] : customer.address;
	args["ssl_city"] = customer.city;
	args["ssl_state"] = customer.state;
	args["ssl_avs_zip"] = customer.zip;
	if(customer.phoneNumber.length)
		args["ssl_phone"] = customer.phoneNumber;
	args["ssl_email"] = customer.emailAddress;

	args["ssl_customer_code"] = "";
	args["ssl_salestax"] = "0.00";


	auto returned = doVirtualMerchantRequest(credentials, args);

	if("ssl_recurring_id" in returned)
		return returned["ssl_recurring_id"];
	else {
		throw new VirtualMerchantGatewayException(
			to!int(returned["errorCode"]),
			returned["errorMessage"],
			returned["errorName"],
			returned
		);
	}

	assert(0);
}

string[string] doVirtualMerchantRequest(in VirtualMerchantCredentials credentials, string[string] args) {

	args["ssl_merchant_id"] = credentials.merchantId;
	args["ssl_user_id"] = credentials.userId;
	args["ssl_pin"] = credentials.pin;

	// see page 110
	enum testUrl = "https://demo.myvirtualmerchant.com/VirtualMerchantDemo/process.do";
	enum liveUrl = "https://www.myvirtualmerchant.com/VirtualMerchant/process.do";

	version(live)
		auto url = liveUrl;
	else
		auto url = testUrl;

	import arsd.cgi;
	auto infoTxt = curl(url, encodeVariables(args));

	string[string] returned;
	foreach(line; infoTxt.split("\n")) {
		if(line.length == 0)
			continue;
		string key, value;
		auto idx = line.indexOf("=");
		if(idx == -1)
			key = line.strip;
		else {
			key = line[0 .. idx].strip;
			value = line[idx + 1 .. $].strip;
		}

		returned[key] = value;
	}

	return returned;
}

/**
	Creates a subscription with Authorize.net, returning the new subscription ID.

	params:
		subscription = Info about the subscription itself - price, name, and interval
		startDate = when the subscription goes into effect. The first credit card charge will come on this date.
		customer = basic info about the customer
		card = the credit card information to bill
		referenceId = an optional field to be stored with the subscription inside authorize.net, can be anything

	returns:
		The new subscription id from authorize.net

	throws:
		AuthorizeGatewayException if something goes wrong
*/
string createSubscription(in SubscriptionInfo subscription, in Date startDate, in CustomerInfo customer, in CreditCard card, in string referenceId = null) {
	/* Authorize.net parameters */

	version(live) {
		// FIXME: this is dummy test info
		enum string loginname="8vLAwF38qF";
		enum string transactionkey="6sYgn3u3Nx98r5Tb";
		enum string host = "apitest.authorize.net";
		enum string path = "/xml/v1/request.api";

		// enum string host = "api.authorize.net";
		// enum string path = "/xml/v1/request.api";
	} else {
		// use the test gateway on dev
		enum string loginname="8vLAwF38qF";
		enum string transactionkey="6sYgn3u3Nx98r5Tb";
		enum string host = "apitest.authorize.net";
		enum string path = "/xml/v1/request.api";
	}

	// we want it to continue forever
	immutable totalOccurrences = 9999;

	// we don't use the trial feature
	immutable trialAmount = subscription.trialAmount.toString()[1..$];
	immutable trialOccurrences = subscription.trialOccurrences;


	/* ********* */
	/* Real code */
	/* ********* */

	string shortenedName = subscription.name;
	if(shortenedName.length > 50)
		shortenedName = shortenedName[0..50]; // to ensure we have good data for auth.net

	//build xml to post
	string content =
		"<?xml version=\"1.0\" encoding=\"utf-8\"?>" ~
		"<ARBCreateSubscriptionRequest xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\">" ~
		"<merchantAuthentication>" ~
			"<name>" ~ loginname ~ "</name>" ~
			"<transactionKey>" ~ transactionkey ~ "</transactionKey>" ~
		"</merchantAuthentication>" ~
			"<refId>" ~ xmlEntitiesEncode(referenceId)  ~ "</refId>" ~
		"<subscription>" ~
			"<name>" ~ xmlEntitiesEncode(shortenedName) ~ "</name>" ~
			"<paymentSchedule>" ~
				"<interval>" ~
					"<length>" ~ to!string(subscription.durationLength) ~ "</length>" ~
					"<unit>" ~ subscription.unitString ~ "</unit>" ~
				"</interval>" ~
				"<startDate>" ~ startDate.toDateString() ~ "</startDate>" ~
				"<totalOccurrences>" ~ to!string(totalOccurrences) ~ "</totalOccurrences>" ~
				"<trialOccurrences>" ~ to!string(trialOccurrences) ~ "</trialOccurrences>" ~
			"</paymentSchedule>" ~
			"<amount>" ~ subscription.amount.toString()[1..$] ~ "</amount>" ~ // toString returns $n.nn, we don't want a $
			"<trialAmount>" ~ to!string(trialAmount) ~ "</trialAmount>" ~
			"<payment>" ~
				"<creditCard>" ~
					"<cardNumber>" ~ card.cardNumber ~ "</cardNumber>" ~
					"<expirationDate>" ~ card.expirationDate ~ "</expirationDate>" ~
				"</creditCard>" ~
			"</payment>" ~
			"<customer>" ~
				"<email>" ~     xmlEntitiesEncode(customer.emailAddress) ~ "</email>" ~
				"<phoneNumber>" ~     xmlEntitiesEncode(customer.phoneNumber) ~ "</phoneNumber>" ~
			"</customer>" ~
			"<billTo>" ~
				"<firstName>" ~ xmlEntitiesEncode(customer.firstName) ~ "</firstName>" ~
				"<lastName>" ~  xmlEntitiesEncode(customer.lastName) ~ "</lastName>" ~
				"<company>" ~  xmlEntitiesEncode(customer.company) ~ "</company>" ~
				"<address>" ~  xmlEntitiesEncode(customer.address ~ "\n" ~ customer.address2) ~ "</address>" ~
				"<city>" ~  xmlEntitiesEncode(customer.city) ~ "</city>" ~
				"<state>" ~  xmlEntitiesEncode(customer.state) ~ "</state>" ~
				"<zip>" ~  xmlEntitiesEncode(customer.zip) ~ "</zip>" ~
			"</billTo>" ~
		"</subscription>" ~
		"</ARBCreateSubscriptionRequest>";


	string response = curl("https://" ~ host ~ path, content, "text/xml");

	int xmlroot = response.indexOf("><");
	if(xmlroot == -1)
		throw new AuthorizeGatewayException("Create subscription", null, "Bad response");

	string xml = response[xmlroot+1..$];

	Document doc = new Document(xml);

	auto result = doc.getElementsByTagName("resultCode");
	if(result.length == 0)
		throw new AuthorizeGatewayException("Create subscription", null, "Bad response, no result code");

	auto e = result[0].innerText;

	if(e != "Ok") {
		// buy failed, get the message out:

		auto eles = doc.getElementsByTagName("text");
		if(eles.length == 0) // don't know the message...
			throw new AuthorizeGatewayException("Create subscription", null, "Reason unknown");
		else
			throw new AuthorizeGatewayException("Create subscription", doc.requireSelector("code").innerText, eles[0].innerText);
	}

	auto s = doc.getElementsByTagName("subscriptionId");
	if(s.length == 0)
		throw new Exception("Bad response");
	auto subId = s[0].innerText;

	return subId;
}

string oneTimeBill(string login, string key, CustomerInfo customer, CreditCard card, Money amount, string description, string[string] otherArgs = null) {
	version(live) {
		string host = "https://test.authorize.net/gateway/transact.dll";
		// FIXME
		// string host = "https://secure.authorize.net/gateway/transact.dll";
	} else {
		string host = "https://test.authorize.net/gateway/transact.dll";
	}

	/*
		x_login
		x_tran_key
		x_version = 3.0
		x_recurring_billing=1

		x_invoice_num
		x_description

		x_amount
		x_card_num
		x_exp_date = mm/yy
		x_card_code (optional)

		x_first_name
		x_last_name
		x_email



		https://developer.authorize.net/guides/AIM/
	*/

	void setOptional(string k, string v) {
		if(k !in otherArgs)
			otherArgs[k] = v;
	}

	setOptional("x_version", "3.0");
	setOptional("x_recurring_billing", "1");

	otherArgs["x_login"] = login;
	otherArgs["x_tran_key"] = key;
	otherArgs["x_description"] = description;

	otherArgs["x_amount"] = format("%d.%02d", amount.dollars, amount.cents);
	otherArgs["x_card_num"] = card.number;
	otherArgs["x_exp_date"] = format("%02d/%02d", card.expirationMonth, card.expirationYear);

	otherArgs["x_first_name"] = customer.firstName;
	otherArgs["x_lastname"] = customer.lastName;
	otherArgs["x_email"] = customer.emailAddress;

	import arsd.cgi;

	curl(host, encodeVariables(otherArgs)); // FIXME: actually check this

	return null;
}

struct Money {
	int amount;

	this(int numberOfCents) {
		this.amount = numberOfCents;
	}

	this(string val) {
		assert(val.length, "can't pass an empty string as money");
		if(val[0] == '$')
			val = val[1..$];
		val = std.array.replace(val, "%", ""); // HACK

		int idx = val.indexOf(".");
		if(idx == -1)
			amount = to!int(val) * 100;
		else {
			int d = idx ? to!int(val[0..idx]) : 0;
			int c = (idx + 1 < val.length)
				? to!int(val[idx + 1 .. $])
				: 0;

			amount = d * 100 + c;
		}
	}

	static Money fromWebString(string v) {
		if(v.length == 0)
			throw new Exception("Money value must not be empty");
		return Money(v);
	}

	@property int dollars() const {
		return amount / 100;
	}

	@property int cents() const {
		return amount % 100;
	}

	string toString() const {
		return format("$%d.%02d", dollars, cents);
	}

	// a bug in std.conv means this needs to be defined too...
	string toString() {
		return format("$%d.%02d", dollars, cents);
	}

	Money opOpAssign(string op)(Money rhs) {
		mixin("this.amount" ~ op ~"=" ~ "rhs.amount;");
		return this;
	}
}