import { CreationAttributes, CreationOptional, DataTypes, ForeignKey, HasManyGetAssociationsMixin, InferAttributes, InferCreationAttributes, Model, Op } from "sequelize";
import { BboxWithZoom, ID, Latitude, Line, LineCreate, ExtraInfo, LineUpdate, Longitude, PadId, Point, Route, TrackPoint } from "facilmap-types";
import Database from "./database";
import { BboxWithExcept, createModel, dataDefinition, DataModel, getDefaultIdType, getLatType, getLonType, getPosType, getVirtualLatType, getVirtualLonType, makeBboxCondition, makeNotNullForeignKey, validateColour } from "./helpers";
import { groupBy, isEqual, mapValues, omit } from "lodash";
import { wrapAsync } from "../utils/streams";
import { calculateRouteForLine } from "../routing/routing";
import { PadModel } from "./pad";
import { Point as GeoJsonPoint } from "geojson";
import { TypeModel } from "./type";

export type LineWithTrackPoints = Line & {
	trackPoints: TrackPoint[];
}

export interface LineModel extends Model<InferAttributes<LineModel>, InferCreationAttributes<LineModel>> {
	id: CreationOptional<ID>;
	padId: ForeignKey<PadModel["id"]>;
	routePoints: string;
	typeId: ForeignKey<TypeModel["id"]>;
	mode: CreationOptional<string>;
	colour: CreationOptional<string>;
	width: CreationOptional<number>;
	name: CreationOptional<string | null>;
	distance: CreationOptional<number | null>;
	time: CreationOptional<number | null>;
	ascent: CreationOptional<number | null>;
	descent: CreationOptional<number | null>;
	top: Latitude;
	bottom: Latitude;
	left: Longitude;
	right: Longitude;
	extraInfo: CreationOptional<string | null>;

	getLinePoints: HasManyGetAssociationsMixin<LinePointModel>;
	toJSON: () => Line;
}

export interface LinePointModel extends Model<InferAttributes<LinePointModel>, InferCreationAttributes<LinePointModel>> {
	id: CreationOptional<ID>;
	lineId: ForeignKey<LineModel["id"]>;
	pos: GeoJsonPoint;
	lat: Latitude;
	lon: Longitude;
	zoom: number;
	idx: number;
	ele: number | null;
	toJSON: () => TrackPoint;
}

export default class DatabaseLines {

	LineModel = createModel<LineModel>();
	LinePointModel = createModel<LinePointModel>();
	LineDataModel = createModel<DataModel>();

	_db: Database;

	constructor(database: Database) {
		this._db = database;

		this.LineModel.init({
			id: getDefaultIdType(),
			routePoints : {
				type: DataTypes.TEXT,
				allowNull: false,
				get: function(this: LineModel) {
					const routePoints = this.getDataValue("routePoints");
					return routePoints != null ? JSON.parse(routePoints) : routePoints;
				},
				set: function(this: LineModel, v: Point[]) {
					for(let i=0; i<v.length; i++) {
						v[i].lat = Number(v[i].lat.toFixed(6));
						v[i].lon = Number(v[i].lon.toFixed(6));
					}
					this.setDataValue("routePoints", JSON.stringify(v));
				},
				validate: {
					minTwo: function(val: string) {
						const routePoints = JSON.parse(val);
						if(!Array.isArray(routePoints))
							throw new Error("routePoints is not an array");
						if(routePoints.length < 2)
							throw new Error("A line cannot have less than two route points.");
					}
				}
			},
			mode : { type: DataTypes.TEXT, allowNull: false, defaultValue: "" },
			colour : { type: DataTypes.STRING(6), allowNull: false, defaultValue: "0000ff", validate: validateColour },
			width : { type: DataTypes.INTEGER.UNSIGNED, allowNull: false, defaultValue: 4, validate: { min: 1 } },
			name : { type: DataTypes.TEXT, allowNull: true, get: function(this: LineModel) { return this.getDataValue("name") || "Untitled line"; } },
			distance : { type: DataTypes.FLOAT(24, 2).UNSIGNED, allowNull: true },
			time : { type: DataTypes.INTEGER.UNSIGNED, allowNull: true },
			ascent : { type: DataTypes.INTEGER.UNSIGNED, allowNull: true },
			descent : { type: DataTypes.INTEGER.UNSIGNED, allowNull: true },
			top: getLatType(),
			bottom: getLatType(),
			left: getLonType(),
			right: getLonType(),
			extraInfo: {
				type: DataTypes.TEXT,
				allowNull: true,
				get: function(this: LineModel) {
					const extraInfo = this.getDataValue("extraInfo");
					return extraInfo != null ? JSON.parse(extraInfo) : extraInfo;
				},
				set: function(this: LineModel, v: ExtraInfo) {
					this.setDataValue("extraInfo", JSON.stringify(v));
				}
			}
		}, {
			sequelize: this._db._conn,
			modelName: "Line"
		});

		this.LinePointModel.init({
			id: getDefaultIdType(),
			lat: getVirtualLatType(),
			lon: getVirtualLonType(),
			pos: getPosType(),
			zoom: { type: DataTypes.INTEGER.UNSIGNED, allowNull: false, validate: { min: 1, max: 20 } },
			idx: { type: DataTypes.INTEGER.UNSIGNED, allowNull: false },
			ele: { type: DataTypes.INTEGER, allowNull: true }
		}, {
			sequelize: this._db._conn,
			indexes: [
				{ fields: [ "lineId", "zoom" ] }
				// pos index is created in migration
			],
			modelName: "LinePoint"
		});

		this.LineDataModel.init(dataDefinition, {
			sequelize: this._db._conn,
			modelName: "LineData"
		});
	}

	afterInit(): void {
		this.LineModel.belongsTo(this._db.pads.PadModel, makeNotNullForeignKey("pad", "padId"));
		this._db.pads.PadModel.hasMany(this.LineModel, { foreignKey: "padId" });

		// TODO: Cascade
		this.LineModel.belongsTo(this._db.types.TypeModel, makeNotNullForeignKey("type", "typeId", true));

		this.LinePointModel.belongsTo(this.LineModel, makeNotNullForeignKey("line", "lineId"));
		this.LineModel.hasMany(this.LinePointModel, { foreignKey: "lineId" });

		this.LineDataModel.belongsTo(this.LineModel, makeNotNullForeignKey("line", "lineId"));
		this.LineModel.hasMany(this.LineDataModel, { foreignKey: "lineId" });
	}

	getPadLines(padId: PadId, fields?: Array<keyof Line>): Highland.Stream<Line> {
		const cond = fields ? { attributes: fields } : { };
		return this._db.helpers._getPadObjects<Line>("Line", padId, cond);
	}

	getPadLinesByType(padId: PadId, typeId: ID): Highland.Stream<Line> {
		return this._db.helpers._getPadObjects<Line>("Line", padId, { where: { typeId: typeId } });
	}

	getPadLinesWithPoints(padId: PadId): Highland.Stream<LineWithTrackPoints> {
		return this.getPadLines(padId)
			.flatMap(wrapAsync(async (line): Promise<LineWithTrackPoints> => {
				const trackPoints = await this.getAllLinePoints(line.id);
				return { ...line, trackPoints };
			}));
	}

	async getLineTemplate(padId: PadId, data: { typeId: ID }): Promise<Line> {
		const lineTemplate = {
			...this.LineModel.build({ ...data, padId: padId } satisfies Partial<CreationAttributes<LineModel>> as any).toJSON(),
			data: { }
		} as Line;

		const type = await this._db.types.getType(padId, data.typeId);

		if(type.defaultColour)
			lineTemplate.colour = type.defaultColour;
		if(type.defaultWidth)
			lineTemplate.width = type.defaultWidth;
		if(type.defaultMode)
			lineTemplate.mode = type.defaultMode;

		await this._db.helpers._updateObjectStyles(lineTemplate);

		return lineTemplate;
	}

	getLine(padId: PadId, lineId: ID): Promise<Line> {
		return this._db.helpers._getPadObject<Line>("Line", padId, lineId);
	}

	async createLine(padId: PadId, data: LineCreate, trackPointsFromRoute?: Route): Promise<Line> {
		const type = await this._db.types.getType(padId, data.typeId);

		if(type.defaultColour && !data.colour)
			data.colour = type.defaultColour;
		if(type.defaultWidth && !data.width)
			data.width = type.defaultWidth;
		if(type.defaultMode && !data.mode)
			data.mode = type.defaultMode;

		const { trackPoints, ...routeInfo } = await calculateRouteForLine(data, trackPointsFromRoute);

		const dataCopy = { ...data, ...routeInfo };
		delete dataCopy.trackPoints; // They came if mode is track

		const createdLine = await this._db.helpers._createPadObject<Line>("Line", padId, dataCopy);
		await this._db.helpers._updateObjectStyles(createdLine);

		// We have to emit this before calling _setLinePoints so that this event is sent to the client first
		this._db.emit("line", padId, createdLine);

		await this._setLinePoints(padId, createdLine.id, trackPoints);

		return createdLine;
	}

	async updateLine(padId: PadId, lineId: ID, data: LineUpdate, doNotUpdateStyles?: boolean, trackPointsFromRoute?: Route): Promise<Line> {
		const originalLine = await this.getLine(padId, lineId);
		const update = {
			...data,
			routePoints: data.routePoints || originalLine.routePoints,
			mode: (data.mode ?? originalLine.mode) || ""
		};

		let routeInfo;
		if((update.mode == "track" && update.trackPoints) || !isEqual(update.routePoints, originalLine.routePoints) || update.mode != originalLine.mode)
			routeInfo = await calculateRouteForLine(update, trackPointsFromRoute);

		Object.assign(update, mapValues(routeInfo, (val) => val == null ? null : val)); // Use null instead of undefined
		delete update.trackPoints; // They came if mode is track

		const newLine = await this._db.helpers._updatePadObject<Line>("Line", padId, lineId, update, doNotUpdateStyles);

		if(!doNotUpdateStyles)
			await this._db.helpers._updateObjectStyles(newLine); // Modifies newLine

		this._db.emit("line", padId, newLine);

		if(routeInfo)
			await this._setLinePoints(padId, lineId, routeInfo.trackPoints);

		return newLine;
	}

	async _setLinePoints(padId: PadId, lineId: ID, trackPoints: Point[], _noEvent?: boolean): Promise<void> {
		// First get elevation, so that if that fails, we don't update anything
		await this.LinePointModel.destroy({ where: { lineId: lineId } });

		const create = [ ];
		for(let i=0; i<trackPoints.length; i++) {
			create.push({ ...trackPoints[i], lineId: lineId });
		}

		const points = await this._db.helpers._bulkCreateInBatches<TrackPoint>(this.LinePointModel, create);

		if(!_noEvent)
			this._db.emit("linePoints", padId, lineId, points.map((point) => omit(point, ["lineId", "pos"]) as TrackPoint));
	}

	async deleteLine(padId: PadId, lineId: ID): Promise<Line> {
		await this._setLinePoints(padId, lineId, [ ], true);
		const oldLine = await this._db.helpers._deletePadObject<Line>("Line", padId, lineId);
		this._db.emit("deleteLine", padId, { id: lineId });
		return oldLine;
	}

	getLinePointsForPad(padId: PadId, bboxWithZoom: BboxWithZoom & BboxWithExcept): Highland.Stream<{ id: ID; trackPoints: TrackPoint[] }> {
		return this._db.helpers._toStream(async () => await this.LineModel.findAll({ attributes: ["id"], where: { padId } }))
			.map((line) => line.id)
			.batch(50000)
			.flatMap(wrapAsync(async (lineIds) => {
				const linePoints = await this.LinePointModel.findAll({
					where: {
						[Op.and]: [
							{
								zoom: { [Op.lte]: bboxWithZoom.zoom },
								lineId: { [Op.in]: lineIds }
							},
							makeBboxCondition(bboxWithZoom)
						]
					},
					attributes: ["pos", "lat", "lon", "ele", "zoom", "idx", "lineId"]
				});

				return Object.entries(groupBy(linePoints, "lineId")).map(([key, val]) => ({
					id: Number(key),
					trackPoints: val.map((p) => omit(p.toJSON(), ["lineId", "pos"]))
				}));
			})).flatten();
	}

	async getAllLinePoints(lineId: ID): Promise<TrackPoint[]> {
		const points = await this.LineModel.build({ id: lineId } satisfies Partial<CreationAttributes<LineModel>> as any).getLinePoints({
			attributes: [ "pos", "lat", "lon", "ele", "zoom", "idx" ],
			order: [["idx", "ASC"]]
		});
		return points.map((point) => omit(point.toJSON(), ["pos"]) as TrackPoint);
	}

}