#pragma once
#include <vector>
using std::vector;

class Expr;
class Var;

#define MDL_MINIMIZE 1
#define MDL_MAXIMIZE -1

Expr operator+(const Expr& x, const Expr& y);
Expr operator-(const Expr& x, const Expr& y);
Expr operator+(const Expr& x);
Expr operator+(Var x, Var y);
Expr operator+(Var x, double a);
Expr operator+(double a, Var x);
Expr operator-(const Expr& x);
Expr operator-(Var x);
Expr operator-(Var x, Var y);
Expr operator-(Var x, double a);
Expr operator-(double a, Var x);
Expr operator*(double a, Var x);
Expr operator*(Var x, double a);
Expr operator*(const Expr& x, double a);
Expr operator*(double a, const Expr& x);
Expr operator/(Var x, double a);
Expr operator/(const Expr& x, double a);

typedef vector<vector<double>> Matrix;

enum class Rtn {
	LOADED,
	OPTIMAL,
	INFEASIBLE,
	INF_OR_UNBD,
	UNBOUNDED,
	CUTOFF,
	ITERATION_LIMIT,
	NODE_LIMIT,
	TIME_LIMIT,
	SOLUTION_LIMIT,
	INTERRUPTED,
	NUMERIC,
	SUBOPTIMAL,
	INPROGRESS,
	USER_OBJ_LIMIT,
	WORK_LIMIT,
	MEM_LIMIT,
	PIVOT,
};

enum class IntAttr {
	NumConstrs,
	NumVars,
	NumSOS,
	NumQConstrs,
	NumGenConstrs,
	NumNZs,
	NumQNZs,
	NumQCNZs,
	NumIntVars,
	NumBinVars,
	NumPWLObjVars,
	ModelSense,
	IsMIP,
	IsQP,
	IsQCP,
	IsMultiObj,
	Status,
	ConcurrentWinMethod,
	SolCount,
	BarIterCount,
	VBasis,
	CBasis,
	PWLObjCvx,
	BranchPriority,
	VarPreStat,
	BoundVioIndex,
	BoundSVioIndex,
	ConstrVioIndex,
	ConstrSVioIndex,
	ConstrResidualIndex,
	ConstrSResidualIndex,
	DualVioIndex,
	DualSVioIndex,
	DualResidualIndex,
	DualSResidualIndex,
	ComplVioIndex,
	IntVioIndex,
	IISMinimal,
	IISLB,
	IISUB,
	IISConstr,
	IISSOS,
	IISQConstr,
	IISGenConstr,
	IISLBForce,
	IISUBForce,
	IISConstrForce,
	IISSOSForce,
	IISQConstrForce,
	IISGenConstrForce,
	TuneResultCount,
	Lazy,
	VarHintPri,
	ObjNPriority,
	NumObj,
	GenConstrType,
	NumStart,
	Partition,
	LicenseExpiration,
	NumScenarios,
	FuncPieces,
	BatchErrorCode,
	BatchStatus,
	Fingerprint,
	PoolIgnore,
	FuncNonlinear,
	ModelColumn
};

enum class DoubleAttr{
	Runtime,
	Work,
	ObjCon,
	LB,
	UB,
	Obj,
	Start,
	PreFixVal,
	RHS,
	QCRHS,
	Coeff,
	MaxCoeff,
	MinCoeff,
	MaxBound,
	MinBound,
	MaxObjCoeff,
	MinObjCoeff,
	MaxRHS,
	MinRHS,
	MaxQCRHS,
	MinQCRHS,
	MaxQCCoeff,
	MinQCCoeff,
	MaxQCLCoeff,
	MinQCLCoeff,
	MaxQObjCoeff,
	MinQObjCoeff,
	ObjVal,
	ObjBound,
	ObjBoundC,
	MIPGap,
	IterCount,
	NodeCount,
	X,
	RC,
	Pi,
	QCPi,
	Slack,
	QCSlack,
	MaxVio,
	BoundVio,
	BoundSVio,
	BoundVioSum,
	BoundSVioSum,
	ConstrVio,
	ConstrSVio,
	ConstrVioSum,
	ConstrSVioSum,
	ConstrResidual,
	ConstrSResidual,
	ConstrResidualSum,
	ConstrSResidualSum,
	DualVio,
	DualSVio,
	DualVioSum,
	DualSVioSum,
	DualResidual,
	DualSResidual,
	DualResidualSum,
	DualSResidualSum,
	ComplVio,
	ComplVioSum,
	IntVio,
	IntVioSum,
	Kappa,
	KappaExact,
	SAObjLow,
	SAObjUp,
	SALBLow,
	SALBUp,
	SARHSLow,
	SAUBLow,
	SAUBUp,
	SARHSUp,
	Xn,
	FarkasProof,
	FarkasDual,
	UnbdRay,
	PStart,
	DStart,
	BarX,
	VarHintVal,
	ObjN,
	ObjNCon,
	ObjNWeight,
	ObjNRelTol,
	ObjNAbsTol,
	ObjNVal,
	OpenNodeCount,
	PoolObjBound,
	PoolObjVal,
	ScenNLB,
	ScenNUB,
	ScenNObj,
	ScenNRHS,
	ScenNX,
	ScenNObjBound,
	ScenNObjVal,
	FuncPieceError,
	FuncPieceLength,
	FuncPieceRatio,
	DNumNZs
};

enum class StringAttr {
	ModelName,
	VarName,
	ConstrName,
	QCName,
	GenConstrName,
	ObjNName,
	ScenNName,
	BatchID,
	VTag,
	CTag,
	QCTag,
	BatchErrorMessage
};

enum class ConstrOper {
	LESS_EQUAL,
	GREATER_EQUAL,
	EQUAL
};

class Var {
public:
	Var(double coef = 1) :col(0), val(0), coeffs(coef) {};
	double get(DoubleAttr attr);
	int get(IntAttr attr);
	friend class Model;
	friend class Expr;
private:
	double coeffs;
	double val;
	int col;
};

class Expr
{
private:
	double constant;
	std::vector<double> coeffs;
	std::vector<Var> vars;

public:
	Expr(const Expr& expr) = default;
	Expr(double constant = 0.0);
	Expr(Var var, double coeff = 1.0);

	friend class Model;

	friend Expr operator+(const Expr& x, const Expr& y);
	friend Expr operator+(const Expr& x);
	friend Expr operator+(Var x, Var y);
	friend Expr operator+(Var x, double a);
	friend Expr operator+(double a, Var x);
	friend Expr operator-(const Expr& x, const Expr& y);
	friend Expr operator-(const Expr& x);
	friend Expr operator-(Var x);
	friend Expr operator-(Var x, Var y);
	friend Expr operator-(Var x, double a);
	friend Expr operator-(double a, Var x);
	friend Expr operator*(double a, Var x);
	friend Expr operator*(Var x, double a);
	friend Expr operator*(const Expr& x, double a);
	friend Expr operator*(double a, const Expr& x);
	friend Expr operator/(Var x, double a);
	friend Expr operator/(const Expr& x, double a);


	Expr operator=(const Expr& rhs);
	void operator+=(const Expr& expr);
	void operator-=(const Expr& expr);
	void operator*=(double mult);
	void operator/=(double a);
	Expr operator+(const Expr& rhs);
	Expr operator-(const Expr& rhs);
};

class Model
{
public:
	Model();
	Var* addVars(int col);
	void addConstr(const Expr& expr, ConstrOper sense, double rhs);
	void setObjective(Expr obje, int sense = MDL_MAXIMIZE);
	void print();
	Rtn optimize();
	double get(DoubleAttr attr);
	int get(IntAttr attr);
private:
	double _simplex();
	Rtn _pivot(std::pair<size_t, size_t>& p);
	void _gaussian(std::pair<size_t, size_t> p);

	Var* vars;

	Matrix matrix;
	size_t cn, bn;
	vector<int> basic;
	Rtn rtn;
	double res;
	int sense;
};