iobroker.roborock/src/lib/map/v1/MapParser.ts

roborock

// src/lib/map/v1/MapParser.ts
import * as crypto from "node:crypto";
import type { Roborock } from "../../../main";

// --------------------
// Constants
// --------------------
const TYPES = {
	CHARGER_LOCATION: 1,
	IMAGE: 2,
	PATH: 3,
	GOTO_PATH: 4,
	GOTO_PREDICTED_PATH: 5,
	CURRENTLY_CLEANED_ZONES: 6,
	GOTO_TARGET: 7,
	ROBOT_POSITION: 8,
	FORBIDDEN_ZONES: 9,
	VIRTUAL_WALLS: 10,
	CURRENTLY_CLEANED_BLOCKS: 11,
	NO_MOP_ZONE: 12,
	OBSTACLES: 13,
	IGNORED_OBSTACLES: 14,
	OBSTACLES2: 15,
	IGNORED_OBSTACLES2: 16,
	CARPET_MAP: 17,
	MOP_PATH: 18,
	CARPET_FORBIDDEN_ZONE: 19,
	SMART_ZONE_PATH_TYPE: 20,
	SMART_ZONE: 21,
	CUSTOM_CARPET: 22,
	CL_FORBIDDEN_ZONES: 23,
	FLOOR_MAP: 24,
	FURNITURES: 25,
	DOCK_TYPE: 26,
	ENEMIES: 27,
	DS_FORBIDDEN_ZONES: 28,
	STUCK_POINTS: 29,
	CLF_FORBIDDEN_ZONES: 30,
	SMART_DS: 31,
	FLOOR_DIRECTION: 32,
	DATE: 33,
	NONCEDATA: 34,
	EXT_ZONES: 36,
	PATROL: 37,
	PET_PATROL: 38,
	MODE_CARPET: 39,
	STROY_PT: 41,
	DIRTY_RECT: 42,
	IGNORE_DIRTY_RECT: 43,
	BRUSH_PT: 44,
	DIRTY_NEW: 45,
	MOP_ERR_PT: 46,
	ERAZER_ZONE: 47,
	LONG_CARPET: 48,
	DS_SIDES: 49,
	STEERING_PT: 50,
	SENSOR_INFO: 51,
	LOW_SPACES: 52,
	TIDY_ZONES: 53,
	GARBAGE: 54,
	ZONE_LINES: 55,
	DIGEST: 1024,
	/** Not in app workermapparser.jx (gap between 34 and 36). */
	UNKNOWN_35: 35,
	/** Not in app workermapparser.jx (gap between 39 and 41). */
	UNKNOWN_40: 40,
	/** Not in app workermapparser.jx (gap between 55 and 57). */
	UNKNOWN_56: 56,
	/** Block 59: curtain zones (门帘). From app workermapparser.jx type "curtain". */
	CURTAIN: 59,
	/** Block 60: missed-cleaning areas (漏扫的区域). From app workermapparser.jx type "missZone". */
	MISS_ZONE: 60,
};
const TYPES_REVERSE = Object.fromEntries(Object.entries(TYPES).map(([key, value]) => [value, key]));
const OFFSETS = {
	HLENGTH: 0x02,
	LENGTH: 0x04,
	TYPE_COUNT: 0x08,
	TARGET_X: 0x08,
	ANGLE: 0x10,
	PATH: 0x14,
	TARGET_Y: 0x0a,
	BLOCKS: 0x0c,
};

// --------------------
// Interfaces
// --------------------
interface MapMetaData {
	header_length: number;
	data_length: number;
	version: { major: number; minor: number };
	map_index: number;
	map_sequence: number;
	SHA1: string;
	expectedSHA1: string;
}
interface PositionBlock {
	position: [number, number];
	angle: number;
}
interface SegmentInfo {
	id: number; // The segment ID (e.g., 16)
	name: string; // The room name (e.g., "Kitchen")
	center: [number, number]; // The calculated center coordinates in MM
}
interface ImageBlock {
	segments: {
		count: number;
		list: SegmentInfo[];
	};
	position: { top: number; left: number };
	dimensions: { height: number; width: number };
	pixels: { floor: number[]; obstacle: number[]; segments: number[] };
}
interface PathBlock {
	current_angle: number;
	points: [number, number][];
}
type Obstacle = [number, number, number, number, number, number, string];
interface NonceData {
	type: number;
	unixTime: number;
}
export interface ParsedMapData {
	metaData: MapMetaData;
	ROBOT_POSITION?: PositionBlock;
	CHARGER_LOCATION?: PositionBlock;
	IMAGE?: ImageBlock;
	PATH?: PathBlock;
	GOTO_PATH?: PathBlock;
	GOTO_PREDICTED_PATH?: PathBlock;
	CURRENTLY_CLEANED_ZONES?: number[][];
	GOTO_TARGET?: [number, number];
	VIRTUAL_WALLS?: number[][];
	CURRENTLY_CLEANED_BLOCKS?: number[];
	FORBIDDEN_ZONES?: number[][];
	NO_MOP_ZONE?: number[][];
	OBSTACLES2?: Obstacle[];
	CARPET_MAP?: number[];
	MOP_PATH?: number[];
	CARPET_FORBIDDEN_ZONE?: number[][];
	DS_FORBIDDEN_ZONES?: number[][];
	CLF_FORBIDDEN_ZONES?: number[][];
	MODE_CARPET?: number[][];
	NONCEDATA?: NonceData[];
	STROY_PT?: any[];
	DIRTY_RECT?: any[];
	IGNORE_DIRTY_RECT?: any[];
	BRUSH_PT?: any[];
	DIRTY_NEW?: any[];
	MOP_ERR_PT?: any[];
	ERAZER_ZONE?: any[];
	LONG_CARPET?: any[];
	DS_SIDES?: any[];
	STEERING_PT?: any[];
	SENSOR_INFO?: any[];
	LOW_SPACES?: any[];
	TIDY_ZONES?: any[];
	GARBAGE?: any[];
	ZONE_LINES?: any[];
	OBSTACLES?: any[];
	IGNORED_OBSTACLES?: any[];
	IGNORED_OBSTACLES2?: any[];
	SMART_ZONE_PATH_TYPE?: number;
	SMART_ZONE?: any[];
	CUSTOM_CARPET?: any[];
	FLOOR_MAP?: number[];
	FURNITURES?: any[];
	DOCK_TYPE?: number;
	ENEMIES?: any[];
	STUCK_POINTS?: any[];
	SMART_DS?: any[];
	FLOOR_DIRECTION?: any[];
	DATE?: number;
	EXT_ZONES?: any[];
	PATROL?: any[];
	PET_PATROL?: any[];
}

export class MapParser {
	adapter: Roborock;

	constructor(adapter: Roborock) {
		this.adapter = adapter;
	}

	/**
	 * Parses the raw map data from V1 Roborock vacuums.
	 * @see test/unit/v1_map_specification.test.ts for the binary format specification.
	 */
	async parsedata(buf: Buffer, mappedRooms: any[] | null, options: { isHistoryMap?: boolean; duid?: string } = { isHistoryMap: false }): Promise<ParsedMapData | {}> {
		if (buf.length < 8) {
			this.adapter.rLog("MapManager", null, "Warn", "1.0", undefined, `Received map buffer is too small (< 8 bytes). Length: ${buf.length}`, "warn");
			return {};
		}

		let metaData: MapMetaData;
		let dataPosition = 0;
		let dataLength = buf.length;

		if (buf.length >= 20 && buf[0x00] === 0x72 && buf[0x01] === 0x72) {
			metaData = this.parseHeader(buf);

			if (!metaData.header_length) {
				this.adapter.rLog("MapManager", null, "Error", "1.0", undefined, "Failed to parse LIVE map header (Invalid structure).", "error");
				return {};
			}
			if (metaData.SHA1 !== metaData.expectedSHA1) {
				this.adapter.rLog("MapManager", null, "Error", "1.0", undefined, "Invalid map hash!", "error");
				return {};
			}

			dataPosition = 0x14; // Skip 20-byte header
			dataLength = metaData.data_length;
		} else if (options.isHistoryMap) {
			this.adapter.rLog("MapManager", null, "Debug", "1.0", undefined, "Parsing as History Map (No 'rr' Header).", "debug");
			metaData = { map_index: -1 } as any;
			dataPosition = 0;
			dataLength = buf.length;
		} else {
			this.adapter.rLog("MapManager", null, "Warn", "1.0", undefined, "Invalid map header signature (expected 'rr').", "warn");
			return {};
		}

		const result: any = { metaData };

		const roomIDsAll = options.duid && this.adapter.http_api.isSharedDevice(options.duid)
			? await this.adapter.http_api.getSharedDeviceRooms(options.duid)
			: this.adapter.http_api.getMatchedRoomIDs(false);

		// Loop through all blocks
		while (dataPosition < dataLength) {
			if (dataPosition + OFFSETS.LENGTH + 4 > buf.length) {
				this.adapter.rLog("MapManager", null, "Warn", "1.0", undefined, "Reached end of buffer prematurely while reading block header.", "warn");
				break;
			}

			const type = buf.readUInt16LE(dataPosition);
			const hlength = buf.readUInt16LE(dataPosition + OFFSETS.HLENGTH);
			const length = buf.readUInt32LE(dataPosition + OFFSETS.LENGTH);

			if (dataPosition + hlength + length > buf.length) {
				this.adapter.rLog("MapManager", null, "Warn", "1.0", undefined, `Block (Type ${type}) claims to be larger than buffer. Stopping parse.`, "warn");
				break;
			}

			const blockBuffer = buf.subarray(dataPosition, dataPosition + hlength + length);
			const [offset1, offset2] = this.getTwoByteOffsets(blockBuffer);

			const typeName = TYPES_REVERSE[type];
			if (typeName) {
				try {
					switch (type) {
						case TYPES.ROBOT_POSITION:
						case TYPES.CHARGER_LOCATION: {
							const position = this.getXYPositions(blockBuffer, offset1, offset2);
							const angle = length >= 12 ? this.getAngle(blockBuffer) : 0;
							result[typeName] = { position, angle };
							break;
						}
						case TYPES.IMAGE: {
							result[typeName] = this.parseImageBlock(blockBuffer, buf, dataPosition, length, hlength, mappedRooms, roomIDsAll);
							break;
						}
						case TYPES.CARPET_MAP: {
							const carpets: number[] = [];
							const dataStart = dataPosition + offset1;
							for (let i = 0; i < length; i++) {
								if (this.getPixelType(buf, dataStart + i) === 1) {
									carpets.push(i);
								}
							}
							result[typeName] = carpets;
							break;
						}
						case TYPES.MOP_PATH: {
							const mopPath: number[] = [];
							const dataStart = dataPosition + hlength;
							for (let i = 0; i < length; i++) {
								mopPath.push(...this.readUInt8(buf, dataStart + i, 0, 1));
							}
							result[typeName] = mopPath;
							break;
						}
						case TYPES.PATH:
						case TYPES.GOTO_PATH:
						case TYPES.GOTO_PREDICTED_PATH: {
							result[typeName] = this.parsePathBlock(blockBuffer, buf, dataPosition, length);
							break;
						}
						case TYPES.GOTO_TARGET:
							result[typeName] = this.getGoToTarget(blockBuffer);
							break;

						case TYPES.CURRENTLY_CLEANED_ZONES:
						case TYPES.VIRTUAL_WALLS: {
							const count = this.getCount(blockBuffer);
							const zones: number[][] = [];
							const dataStart = dataPosition + hlength;
							for (let i = 0; i < count; i++) {
								zones.push(this.readUInt16LE(buf, dataStart + i * 8, 0, 4));
							}
							result[typeName] = zones;
							break;
						}
						case TYPES.FORBIDDEN_ZONES:
						case TYPES.NO_MOP_ZONE:
						case TYPES.CARPET_FORBIDDEN_ZONE:
						case TYPES.DS_FORBIDDEN_ZONES:
						case TYPES.CLF_FORBIDDEN_ZONES:
						case TYPES.MODE_CARPET: {
							const count = this.getCount(blockBuffer);
							const zones: number[][] = [];
							const dataStart = dataPosition + hlength;
							for (let i = 0; i < count; i++) {
								zones.push(this.getForbiddenZone(buf, dataStart + i * 16, 0));
							}
							result[typeName] = zones;
							break;
						}
						case TYPES.OBSTACLES2:
							result[typeName] = this.extractObstacles(blockBuffer, hlength);
							break;
						case TYPES.CURRENTLY_CLEANED_BLOCKS: {
							const count = this.getCount(blockBuffer);
							const blocks: number[] = [];
							for (let i = 0; i < count; i++) {
								blocks.push(buf.readUInt8(dataPosition + OFFSETS.BLOCKS + i));
							}
							result[typeName] = blocks;
							break;
						}
						case TYPES.NONCEDATA:
							result[typeName] = this.getNonceData(blockBuffer);
							break;
						case TYPES.STROY_PT:
							result[typeName] = this.getStroyPt(blockBuffer, hlength);
							break;
						case TYPES.DIRTY_RECT:
						case TYPES.IGNORE_DIRTY_RECT:
							result[typeName] = this.getDirtyRect(blockBuffer, hlength);
							break;
						case TYPES.BRUSH_PT:
							result[typeName] = this.getBrushPt(blockBuffer, hlength);
							break;
						case TYPES.DIRTY_NEW:
							result[typeName] = this.getDirtyNew(blockBuffer, hlength, length);
							break;
						case TYPES.MOP_ERR_PT:
							result[typeName] = this.getMopErrPt(blockBuffer, hlength);
							break;
						case TYPES.ERAZER_ZONE:
						case TYPES.LOW_SPACES:
							result[typeName] = this.getEraserZone(blockBuffer, hlength, length);
							break;
						case TYPES.LONG_CARPET:
							result[typeName] = this.getLongCarpet(blockBuffer, hlength, length);
							break;
						case TYPES.DS_SIDES:
							result[typeName] = this.getDsSides(blockBuffer, hlength, length);
							break;
						case TYPES.STEERING_PT:
							result[typeName] = this.getSteeringPt(blockBuffer, hlength, length);
							break;
						case TYPES.SENSOR_INFO:
							result[typeName] = this.getSensorInfo(blockBuffer, hlength, length);
							break;
						case TYPES.TIDY_ZONES:
							result[typeName] = this.getTidyZones(blockBuffer, hlength, length);
							break;
						case TYPES.GARBAGE:
							result[typeName] = this.getGarbage(blockBuffer, hlength, length);
							break;
						case TYPES.ZONE_LINES:
							result[typeName] = this.getZoneLines(blockBuffer, hlength);
							break;
						case TYPES.OBSTACLES:
						case TYPES.IGNORED_OBSTACLES:
							result[typeName] = this.getObstaclesOld(blockBuffer, hlength);
							break;
						case TYPES.IGNORED_OBSTACLES2:
							result[typeName] = this.getIgnoredObstacles2(blockBuffer, hlength);
							break;
						case TYPES.SMART_ZONE_PATH_TYPE:
							result[typeName] = buf.readUInt8(dataPosition + offset1);
							break;
						case TYPES.SMART_ZONE:
							result[typeName] = this.getSmartZone(blockBuffer, hlength);
							break;
						case TYPES.CUSTOM_CARPET:
						case TYPES.CL_FORBIDDEN_ZONES:
						case TYPES.SMART_DS:
						case TYPES.EXT_ZONES:
							result[typeName] = this.getForbiddenZone(buf, dataPosition + hlength, 0); // Re-use getForbiddenZone as structure is same (16 bytes)
							break;
						case TYPES.FLOOR_MAP:
							result[typeName] = this.readUInt8(buf, dataPosition, hlength, length);
							break;
						case TYPES.FURNITURES:
							result[typeName] = this.getFurnitures(blockBuffer, hlength);
							break;
						case TYPES.DOCK_TYPE:
							result[typeName] = buf.readUInt8(dataPosition + offset1);
							break;
						case TYPES.ENEMIES:
						case TYPES.STUCK_POINTS:
							result[typeName] = this.getEnemies(blockBuffer, hlength);
							break;
						case TYPES.FLOOR_DIRECTION:
							result[typeName] = this.getFloorDirection(blockBuffer, hlength, length);
							break;
						case TYPES.DATE:
							result[typeName] = buf.readUInt32LE(dataPosition + offset1);
							break;
						case TYPES.PATROL:
						case TYPES.PET_PATROL:
							result[typeName] = this.getPatrol(blockBuffer, hlength);
							break;
						case TYPES.CURTAIN: {
							const count = this.getCount(blockBuffer);
							const zones: number[][] = [];
							const dataStart = dataPosition + hlength;
							const entryLen = 20; // 8 coords (16 B) + status (2 B) + count (2 B)
							for (let i = 0; i < count && dataStart + (i + 1) * entryLen <= dataPosition + hlength + length; i++) {
								zones.push(this.readUInt16LE(buf, dataStart + i * entryLen, 0, 8));
							}
							result[typeName] = zones;
							break;
						}
						case TYPES.MISS_ZONE: {
							const count = this.getCount(blockBuffer);
							const zones: number[][] = [];
							const dataStart = dataPosition + hlength;
							const payloadLen = length;
							const entryLen = count > 0 ? Math.floor(payloadLen / count) : 0; // 29 or 31
							for (let i = 0; i < count && entryLen >= 29; i++) {
								zones.push(this.readUInt16LE(buf, dataStart + i * entryLen + 12, 0, 8));
							}
							result[typeName] = zones;
							break;
						}
						case TYPES.UNKNOWN_35:
						case TYPES.UNKNOWN_40:
						case TYPES.UNKNOWN_56:
							this.adapter.rLog("MapManager", null, "Info", "1.0", undefined, `Unknown map block (report for analysis): type=${type} length=${length} hex=${blockBuffer.toString("hex")}`, "info");
							break;
					}
				} catch (e: any) {
					this.adapter.rLog("MapManager", null, "Error", "1.0", undefined, `Error parsing block ${typeName} (Type ${type}): ${e.stack}`, "error");
				}
			} else {
				this.adapter.rLog("MapManager", null, "Warn", "1.0", undefined, `Unknown map block (report for analysis): type=${type} length=${length} hex=${blockBuffer.toString("hex")}`, "warn");
			}
			dataPosition += length + hlength;
		}
		return result;
	}

	private parseHeader(mapBuf: Buffer): MapMetaData {
		return {
			header_length: mapBuf.readUInt16LE(OFFSETS.HLENGTH),
			data_length: mapBuf.readUInt32LE(OFFSETS.LENGTH),
			version: {
				major: mapBuf.readUInt16LE(0x08),
				minor: mapBuf.readUInt16LE(0x0a),
			},
			map_index: mapBuf.readUInt32LE(0x0c),
			map_sequence: mapBuf.readUInt32LE(0x10),
			SHA1: crypto
				.createHash("sha1")
				.update(mapBuf.subarray(0, mapBuf.length - 20))
				.digest("hex"),
			expectedSHA1: mapBuf.subarray(mapBuf.length - 20).toString("hex"),
		};
	}

	private parseImageBlock(
		blockBuffer: Buffer,
		buf: Buffer,
		dataPosition: number,
		length: number,
		hlength: number,
		mappedRooms: any[] | null,
		roomIDsAll: { id: number; name: string }[]
	): ImageBlock {
		// MM per pixel (5cm)
		const MM_PER_PIXEL = 50;

		// Get unscaled pixel dimensions and offsets
		const offset = this.getSingleByteOffset(blockBuffer);
		const { left, top, width: width_px, height: height_px } = this.getMapSizes(blockBuffer, offset);

		const parameters: ImageBlock = {
			segments: {
				count: hlength > 24 ? this.getCount(blockBuffer) : 0,
				list: [],
			},
			position: { top, left },
			dimensions: { height: height_px, width: width_px },
			pixels: { floor: [], obstacle: [], segments: [] },
		};

		if (height_px <= 0 || width_px <= 0) return parameters;

		// Create Bounding Boxes for segments
		const segBB: Record<number, { minX: number; maxX: number; minY: number; maxY: number; count: number }> = {};
		const segmentIDsInImage: Set<number> = new Set();

		const dataStart = dataPosition + offset;

		for (let i = 0; i < length; i++) {
			const pixelBytePosition = dataStart + i;
			const pixelType = this.getPixelType(buf, pixelBytePosition);

			if (pixelType === 1) {
				// Obstacle
				parameters.pixels.obstacle.push(i);
			} else if (pixelType !== 0) {
				// Floor
				parameters.pixels.floor.push(i);

				const segmentID = (buf.readUInt8(pixelBytePosition) & 248) >> 3;
				segmentIDsInImage.add(segmentID);

				parameters.pixels.segments.push(i | (segmentID << 21));

				// Calculate UN-SCALED pixel coordinates relative to the data block (0, 0)
				const x = i % width_px;
				const y = Math.floor(i / width_px);

				const bb = segBB[segmentID];
				if (!bb) {
					segBB[segmentID] = { minX: x, maxX: x, minY: y, maxY: y, count: 1 };
				} else {
					if (x < bb.minX) bb.minX = x;
					if (x > bb.maxX) bb.maxX = x;
					if (y < bb.minY) bb.minY = y;
					if (y > bb.maxY) bb.maxY = y;
					bb.count++;
				}
			}
		}

		// --- Process all found segments ---

		for (const segId of segmentIDsInImage) {
			if (segId === 0) continue; // Skip "no segment"

			const bb = segBB[segId];
			if (!bb) continue;

			const centerX_px = Math.round((bb.minX + bb.maxX) / 2);
			const centerY_px = Math.round((bb.minY + bb.maxY) / 2);

			// This logic MUST match the working localCoordsToRobotCoords formula
			// x_robot = (center_x_px + offset_x_px) * MM_PER_PIXEL
			// y_robot = ((height_px / scale) + top_px - center_y_px) * MM_PER_PIXEL

			const centerX_robot = Math.round((centerX_px + left) * MM_PER_PIXEL);

			// NOTE: The map creator scales dimensions.height by map_scale, which cancels out:
			// (height_px * scale / scale) = height_px
			const centerY_robot = Math.round((centerY_px + top) * MM_PER_PIXEL);

			let roomName = "";
			const mapping = mappedRooms?.find(([id]) => parseInt(id) === segId);
			if (mapping) {
				const roomApiID = mapping[1];
				const roomObj = roomIDsAll.find((r) => String(r.id) === String(roomApiID));
				roomName = roomObj?.name || "";
			}

			parameters.segments.list.push({
				id: segId,
				name: roomName,
				center: [centerX_robot, centerY_robot], // Store correct MM coordinates
			});
		}

		return parameters;
	}

	private parsePathBlock(blockBuffer: Buffer, buf: Buffer, dataPosition: number, length: number): PathBlock {
		const pathData: PathBlock = {
			current_angle: this.getAngle(blockBuffer),
			points: [],
		};
		const pathDataPosition = dataPosition + OFFSETS.PATH;

		for (let i = 0; i < length; i += 4) {
			pathData.points.push(this.getPointInPath(buf, pathDataPosition + i));
		}

		if (pathData.points.length >= 2) {
			const last = pathData.points[pathData.points.length - 1];
			const secondLast = pathData.points[pathData.points.length - 2];
			pathData.current_angle = (Math.atan2(last[1] - secondLast[1], last[0] - secondLast[0]) * 180) / Math.PI;
		}

		return pathData;
	}

	private extractObstacles(buf: Buffer, offset: number): Obstacle[] {
		const obstacleCount = this.getCount(buf);
		const obstacles: Obstacle[] = [];
		for (let i = 0; i < obstacleCount * 28; i += 28) {
			const obstacle: Obstacle = [
				buf.readUInt16LE(offset + i),
				buf.readUInt16LE(offset + i + 2),
				buf.readUInt16LE(offset + i + 4),
				buf.readUInt16LE(offset + i + 6),
				buf.readUInt16LE(offset + i + 8),
				buf.readUInt16LE(offset + i + 10),
				buf.toString("utf-8", offset + i + 12, offset + i + 12 + 16),
			];
			obstacles.push(obstacle);
		}
		return obstacles;
	}

	private getStroyPt(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const points: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 8;
			points.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2), // y
				buf.readUInt32LE(base + 4) // code
			]);
		}
		return points;
	}

	private getDirtyRect(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 18;
			data.push([
				buf.readUInt16LE(base), // type
				buf.readUInt16LE(base + 2), // x1
				buf.readUInt16LE(base + 4), // y1
				buf.readUInt16LE(base + 6), // x2
				buf.readUInt16LE(base + 8), // y2
				buf.readUInt16LE(base + 10), // x3
				buf.readUInt16LE(base + 12), // y3
				buf.readUInt16LE(base + 14), // x4
				buf.readUInt16LE(base + 16) // y4
			]);
		}
		return data;
	}

	private getBrushPt(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const points: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 4;
			points.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2) // y
			]);
		}
		return points;
	}

	private getDirtyNew(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			const hasImage = buf.readUInt8(base + 18) !== 0;
			data.push([
				buf.readUInt16LE(base), // type
				buf.readUInt16LE(base + 2), // x1
				buf.readUInt16LE(base + 4), // y1
				buf.readUInt16LE(base + 6), // x2
				buf.readUInt16LE(base + 8), // y2
				buf.readUInt16LE(base + 10), // x3
				buf.readUInt16LE(base + 12), // y3
				buf.readUInt16LE(base + 14), // x4
				buf.readUInt16LE(base + 16), // y4
				hasImage ? buf.toString("ascii", base + 18, base + 18 + 16).replace(/\0/g, "") : "" // imageid
			]);
		}
		return data;
	}

	private getMopErrPt(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const points: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 6;
			points.push([
				buf.readUInt8(base), // errorid
				buf.readUInt8(base + 1), // suberrorid
				buf.readUInt16LE(base + 2), // x
				buf.readUInt16LE(base + 4) // y
			]);
		}
		return points;
	}

	private getEraserZone(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			data.push([
				buf.readUInt32LE(base), // type
				buf.readUInt16LE(base + 4), // x1
				buf.readUInt16LE(base + 6), // y1
				buf.readUInt16LE(base + 8), // x2
				buf.readUInt16LE(base + 10), // y2
				buf.readUInt16LE(base + 12), // x3
				buf.readUInt16LE(base + 14), // y3
				buf.readUInt16LE(base + 16), // x4
				buf.readUInt16LE(base + 18) // y4
			]);
		}
		return data;
	}

	private getLongCarpet(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			data.push([
				buf.readUInt32LE(base), // id
				buf.readUInt32LE(base + 4), // total
				buf.readUInt32LE(base + 8) // longhaired
			]);
		}
		return data;
	}

	private getDsSides(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			data.push([
				buf.readUInt8(base), // id
				buf.readUInt8(base + 1),
				buf.readUInt8(base + 2),
				buf.readUInt8(base + 3)
			]);
		}
		return data;
	}

	private getSteeringPt(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			data.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2), // y
				buf.readUInt8(base + 4) // type
			]);
		}
		return data;
	}

	private getSensorInfo(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			data.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2), // y
				buf.readUInt8(base + 4), // type
				buf.readUInt8(base + 5) // status
			]);
		}
		return data;
	}

	private getTidyZones(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			data.push([
				buf.readUInt16LE(base), // id
				buf.readUInt16LE(base + 2), // type
				buf.readUInt16LE(base + 4), // x1
				buf.readUInt16LE(base + 6), // y1
				buf.readUInt16LE(base + 8), // x2
				buf.readUInt16LE(base + 10), // y2
				buf.readUInt16LE(base + 12), // x3
				buf.readUInt16LE(base + 14), // y3
				buf.readUInt16LE(base + 16), // x4
				buf.readUInt16LE(base + 18) // y4
			]);
		}
		return data;
	}

	private getGarbage(buf: Buffer, offset: number, length: number): any[] {
		const count = this.getCount(buf);
		if (count === 0) return [];
		const len = length / count;
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * len;
			data.push([
				buf.readUInt16LE(base), // robot x
				buf.readUInt16LE(base + 2), // robot y
				buf.readUInt16LE(base + 4), // garbage x
				buf.readUInt16LE(base + 6), // garbage y
				buf.readUInt16LE(base + 8), // tidyzone id
				buf.readUInt16LE(base + 10), // garbage id
				buf.toString("utf-8", base + 12, base + len) // tag
			]);
		}
		return data;
	}

	private getZoneLines(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const data: any[] = [];
		let toffset = 0;
		for (let i = 0; i < count; i++) {
			const base = offset + toffset;
			const id = buf.readUInt16LE(base);
			const num = buf.readUInt16LE(base + 2);
			const ptLen = buf.readUInt16LE(base + 4);
			const points: any[] = [];
			for (let j = 0; j < num; j++) {
				const pOff = base + 6 + j * ptLen;
				points.push([
					buf.readUInt16LE(pOff), // x
					buf.readUInt16LE(pOff + 2), // y
					buf.readUIntLE(pOff + 4, ptLen - 4) // type
				]);
			}
			toffset += 6 + num * ptLen;
			data.push({ id, num, ptLen, points });
		}
		return data;
	}

	private getObstaclesOld(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const obstacles: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 5;
			obstacles.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2), // y
				buf.readUInt8(base + 4) // type
			]);
		}
		return obstacles;
	}

	private getIgnoredObstacles2(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const obstacles: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 6;
			obstacles.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2), // y
				buf.readUInt16LE(base + 4) // type
			]);
		}
		return obstacles;
	}

	private getSmartZone(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const zones: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 18;
			zones.push({
				zid: buf.readUInt16LE(base),
				range: [
					buf.readUInt16LE(base + 2),
					buf.readUInt16LE(base + 4),
					buf.readUInt16LE(base + 6),
					buf.readUInt16LE(base + 8)
				]
			});
		}
		return zones;
	}

	private getFurnitures(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const furnitures: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 23;
			furnitures.push([
				buf.readUInt16LE(base), // x1
				buf.readUInt16LE(base + 2), // y1
				buf.readUInt16LE(base + 4), // x2
				buf.readUInt16LE(base + 6), // y2
				buf.readUInt16LE(base + 8), // x3
				buf.readUInt16LE(base + 10), // y3
				buf.readUInt16LE(base + 12), // x4
				buf.readUInt16LE(base + 14), // y4
				buf.readUInt16LE(base + 16), // x_real
				buf.readUInt8(base + 18), // percent
				buf.readUInt8(base + 19), // type
				buf.readUInt8(base + 20), // subtype
				buf.readUInt8(base + 21), // edit
				buf.readUInt8(base + 22) // id
			]);
		}
		return furnitures;
	}

	private getEnemies(buf: Buffer, offset: number): any[] {
		const count = this.getCount(buf);
		const enemies: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 6;
			enemies.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2), // y
				buf.readUInt16LE(base + 4) // type
			]);
		}
		return enemies;
	}

	private getFloorDirection(buf: Buffer, offset: number, length: number): any[] {
		const count = length / 3; // No count header? Code says data.length / 3
		const data: any[] = [];
		for (let i = 0; i < count; i++) {
			const base = offset + i * 3;
			data.push([
				buf.readUInt8(base), // blockid
				buf.readUInt16LE(base + 1) // direction
			]);
		}
		return data;
	}

	private getPatrol(buf: Buffer, offset: number): any[] {
		// Header structure inside data:
		// taskId: 4 bytes (at offset)
		// num: 1 byte (at offset + 4)
		// points: num * 278 bytes (starting at offset + 5)

		if (buf.length < offset + 5) {
			return [];
		}

		const num = buf.readUInt8(offset + 4);
		const points: any[] = [];
		const dataStart = offset + 5;
		const pointSize = 278; // Fixed size per point based on observation

		for (let i = 0; i < num; i++) {
			const base = dataStart + i * pointSize;

			// Ensure we don't read past the buffer
			if (base + 4 > buf.length) {
				this.adapter.rLog("MapManager", null, "Warn", "1.0", undefined, `[MapDataParser] getPatrol: buffer too short for point ${i + 1}/${num}`, "warn");
				break;
			}

			points.push([
				buf.readUInt16LE(base), // x
				buf.readUInt16LE(base + 2) // y
			]);
		}
		return points;
	}

	// --------------------
	// Binary Read Helpers
	// --------------------

	private getXYPositions(buf: Buffer, xOffset: number, yOffset: number): [number, number] {
		const xPosition = buf.readInt32LE(xOffset);
		const yPosition = buf.readInt32LE(yOffset);
		return [xPosition, yPosition];
	}

	/** Reads unscaled pixel dimensions and offsets from the image block header. */
	private getMapSizes(buf: Buffer, offset: number): { left: number; top: number; width: number; height: number } {
		const top = buf.readInt32LE(offset - 0x10); // Unscaled Pixel Offset Y
		const left = buf.readInt32LE(offset - 0x0c); // Unscaled Pixel Offset X
		const height = buf.readInt32LE(offset - 0x08); // Unscaled Pixel Height
		const width = buf.readInt32LE(offset - 0x04); // Unscaled Pixel Width
		return { left, top, width, height };
	}

	private getPointInPath(buf: Buffer, dataPosition: number): [number, number] {
		const x = buf.readUInt16LE(dataPosition);
		const y = buf.readUInt16LE(dataPosition + 2);
		return [x, y];
	}

	private getCount(buf: Buffer): number {
		return buf.readUInt32LE(OFFSETS.TYPE_COUNT);
	}

	private getPixelType(buf: Buffer, dataPosition: number): number {
		return buf.readUInt8(dataPosition) & 0x07;
	}

	private getAngle(buf: Buffer): number {
		return buf.readInt32LE(OFFSETS.ANGLE);
	}

	private getGoToTarget(buf: Buffer): [number, number] {
		return [buf.readUInt16LE(OFFSETS.TARGET_X), buf.readUInt16LE(OFFSETS.TARGET_Y)];
	}

	private getForbiddenZone(buf: Buffer, dataPosition: number, offset: number): number[] {
		return this.readUInt16LE(buf, dataPosition, offset, 8);
	}

	private getSingleByteOffset(buf: Buffer): number {
		return buf.readUInt8(2);
	}

	private getTwoByteOffsets(buf: Buffer): [number, number] {
		return [buf.readUInt8(2), buf.readUInt8(4)];
	}

	private getNonceData(buf: Buffer): NonceData[] {
		const sections: NonceData[] = [];
		for (let i = 12; i < buf.length; i += 5) {
			const type = buf[i];
			const unixTime = buf.readUInt32LE(i + 1);
			sections.push({ type, unixTime });
		}
		return sections;
	}

	private readUInt16LE(buf: Buffer, dataPosition: number, offset: number, count: number): number[] {
		const result: number[] = [];
		for (let j = 0; j < count; j++) {
			result.push(buf.readUInt16LE(dataPosition + offset + j * 2));
		}
		return result;
	}

	private readUInt8(buf: Buffer, dataPosition: number, offset: number, count: number): number[] {
		const array: number[] = [];
		for (let j = 0; j < count; j++) {
			array.push(buf.readUInt8(offset + dataPosition + j));
		}
		return array;
	}
}