import {ParamType, EParamType} from "./types";
import {UserInputHelper} from "./input-helper.user";
import {FileInputHelper} from "./input-helper.upload";
import {BodyInputHelper} from "./input-helper.body";
import {ParamInputHelper, SafeParamInputHelper} from "./input-helper.param";
import bodyParser = require("body-parser");

export interface ArgumentHandlerCallbackType<ReqType, ResType> {
	(name: string): InputHelperBuilder<ReqType, ResType>;
}
export abstract class InputHelperBuilder<ReqType, ResType> {
	protected state: ParamType<ReqType, ResType>;
	protected handlerCallback: ArgumentHandlerCallbackType<ReqType, ResType>;
	
	constructor(parent: {state: ParamType<ReqType, ResType>; handlerCallback?: ArgumentHandlerCallbackType<ReqType, ResType>;}, from?: EParamType) {
		this.state = parent.state;
		this.handlerCallback = parent.handlerCallback;
		if (from !== undefined) {
			this.state.from = from;
		}
	}
	
	_finish() {
		Object.freeze(this);
		Object.freeze(this.state);
	}
	
	_copy() {
		return {
			state: this.state,
			handlerCallback: this.handlerCallback,
		}
	}
	
	_toJSON() {
		return this.state;
	}
	
	from(from: EParamType.TYPE_LOGIN): UserInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_BODY): BodyInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_REWRITE_PATH): ParamInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_GET): ParamInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_POST): ParamInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_UPLOAD): FileInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_COOKIE): ParamInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_SAFE_COOKIE): SafeParamInputHelper<ReqType, ResType>;
	from(from: EParamType.TYPE_SESSION): SafeParamInputHelper<ReqType, ResType>;
	from(from: EParamType): InputHelper<ReqType, ResType>;
	from(from: EParamType): InputHelper<ReqType, ResType> {
		let copy;
		return inputHelperFactory(from, this);
	}
	
	fromLogin(): UserInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_LOGIN, this);
	}
	
	fromBody(): BodyInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_BODY, this);
	}
	
	fromPath(): ParamInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_REWRITE_PATH, this);
	}
	
	fromGet(): ParamInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_GET, this);
	}
	
	fromPost(): ParamInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_POST, this);
	}
	
	fromUpload(): FileInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_UPLOAD, this);
	}
	
	fromCookie(): ParamInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_COOKIE, this);
	}
	
	fromSafeCookie(): SafeParamInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_SAFE_COOKIE, this);
	}
	
	fromSession(): SafeParamInputHelper<ReqType, ResType> {
		return inputHelperFactory(EParamType.TYPE_SESSION, this);
	}
	
	assumeType(type: string) {
		this.state.tsGenerateType = type;
		return this;
	}
	
	handleArgument(name: string): InputHelperBuilder<ReqType, ResType> {
		return this.handlerCallback(name);
	}
}

export abstract class InputHelper<ReqType, ResType> extends InputHelperBuilder<ReqType, ResType> {
	constructor(builder: InputHelperBuilder<ReqType, ResType>, from?: EParamType) {
		super(builder._copy(), from);
	}
}

const {inputHelperFactory} = require("./input-helper.factory");