"use strict";

const Promise = require("bluebird");
const DataLoader = require("dataloader");
const dlayerSource = require("../dlayer-source");
const evaluateAndPick = require("../evaluate-and-pick");
const mapFromSource = require("../map-from-source");
const lvm = require("../exec-lvm");
const All = require("../graphql-interface/symbols/all");

module.exports = {
	name: "LVM",
	makeContext: function () {
		return {
			physicalVolumes: new DataLoader(evaluateAndPick({
				command: lvm.getPhysicalVolumes,
				selectResult: (result) => result.volumes,
				selectID: (device) => device.path
			})),
			volumeGroups: new DataLoader(evaluateAndPick({
				command: lvm.getVolumeGroups,
				selectResult: (result) => result.groups,
				selectID: (group) => group.name
			})),
			logicalVolumes: new DataLoader(evaluateAndPick({
				command: lvm.getLogicalVolumes,
				selectResult: (result) => result.volumes,
				selectID: (volume) => volume.path
			}))
		};
	},
	root: {
		resources: {
			lvm: {
				physicalVolumes: ({ paths }, { physicalVolumes, $make }) => {
					return mapFromSource(physicalVolumes, paths, (volume) => {
						return $make("sysquery.lvm.PhysicalVolume", { path: volume.path });
					});
				},
				volumeGroups: ({ names }, { volumeGroups, $make }) => {
					return mapFromSource(volumeGroups, names, (group) => {
						return $make("sysquery.lvm.VolumeGroup", { name: group.name });
					});
				},
				logicalVolumes: ({ paths }, { logicalVolumes, $make }) => {
					// FIXME: Aren't these scoped to a volume group?
					return mapFromSource(logicalVolumes, paths, (volume) => {
						return $make("sysquery.lvm.LogicalVolume", { path: volume.path });
					});
				}
			}
		}
	},
	extensions: {
		"sysquery.core.BlockDevice": {
			lvmPhysicalVolume: async function (_, { physicalVolumes, $getProperty, $make }) {
				let volume = physicalVolumes.get(await $getProperty(this, "path"));

				if (volume != null) {
					return $make("sysquery.lvm.PhysicalVolume", { path: volume.path });
				} else {
					return null;
				}
			}
		}
	},
	types: {
		"sysquery.lvm.PhysicalVolume": function PhysicalVolume({ path }) {
			return dlayerSource.withSources({
				$sources: {
					physicalVolumes: {
						[dlayerSource.ID]: path,
						path: "path",
						format: "format",
						totalSpace: "totalSpace",
						freeSpace: "freeSpace",
						isExported: "isExported",
						isMissing: "isMissing",
						isAllocatable: "isAllocatable",
						isDuplicate: "isDuplicate",
						isUsed: "isUsed",
						volumeGroup: (volume, { $make }) => {
							return $make("sysquery.lvm.VolumeGroup", { name: volume.volumeGroup });
						}
					}
				}
			});
		},
		"sysquery.lvm.VolumeGroup": function VolumeGroup({ name }) {
			return dlayerSource.withSources({
				physicalVolumes: function (_args, { physicalVolumes, $make }) {
					return Promise.try(() => {
						return physicalVolumes.load(All);
					}).filter((volume) => {
						return (volume.volumeGroup === name);
					}).map((volume) => {
						return $make("sysquery.lvm.PhysicalVolume", { path: volume.path });
					});
				},
				logicalVolumes: function (_args, { logicalVolumes, $make }) {
					return Promise.try(() => {
						return logicalVolumes.load(All);
					}).filter((volume) => {
						return (volume.volumeGroup === name);
					}).map((volume) => {
						return $make("sysquery.lvm.LogicalVolume", { path: volume.path });
					});
				},
				$sources: {
					volumeGroups: {
						[dlayerSource.ID]: name,
						name: "name",
						totalSpace: "totalSpace",
						freeSpace: "freeSpace",
						physicalVolumeCount: "physicalVolumeCount",
						logicalVolumeCount: "logicalVolumeCount",
						snapshotCount: "snapshotCount",
						isReadOnly: "isReadOnly",
						isResizeable: "isResizeable",
						isExported: "isExported",
						isIncomplete: "isIncomplete",
						allocationPolicy: "allocationPolicy",
						mode: "mode"
					}
				}
			});
		},
		"sysquery.lvm.LogicalVolume": function LogicalVolume({ path }) {
			return dlayerSource.withSources({
				$sources: {
					logicalVolumes: {
						[dlayerSource.ID]: path,
						path: "path",
						name: "name",
						fullName: "fullName",
						size: "size",
						uuid: "uuid",
						deviceMapperPath: "deviceMapperPath",
						layoutAttributes: "layoutAttributes",
						roles: "roles",
						tags: "tags",
						configurationProfile: "configurationProfile",
						creationTime: "creationTime",
						creationHost: "creationHost",
						neededKernelModules: "neededKernelModules",
						dataVolume: "dataVolume", // FIXME: Reference?
						metadataVolume: "metadataVolume", // FIXME: Reference?
						poolVolume: "poolVolume", // FIXME: Reference?
						persistentMajorNumber: "persistentMajorNumber",
						persistentMinorNumber: "persistentMinorNumber",
						type: "type",
						isReadOnly: "isReadOnly",
						isCurrentlyReadOnly: "isCurrentlyReadOnly",
						isAllocationLocked: "isAllocationLocked",
						allocationPolicy: "allocationPolicy",
						status: "status",
						healthStatus: "healthStatus",
						isInitiallySynchronized: "isInitiallySynchronized",
						isCurrentlySynchronized: "isCurrentlySynchronized",
						isMerging: "isMerging",
						isConverting: "isConverting",
						isSuspended: "isSuspended",
						isActivationSkipped: "isActivationSkipped",
						isOpened: "isOpened",
						isActiveLocally: "isActiveLocally",
						isActiveRemotely: "isActiveRemotely",
						isActiveExclusively: "isActiveExclusively",
						isMergeFailed: "isMergeFailed",
						isSnapshotInvalid: "isSnapshotInvalid",
						isLiveTablePresent: "isLiveTablePresent",
						isInactiveTablePresent: "isInactiveTablePresent",
						isZeroFilled: "isZeroFilled",
						hasFixedMinorNumber: "hasFixedMinorNumber",
						outOfSpacePolicy: "outOfSpacePolicy",
						volumeGroup: (volume, { $make }) => {
							return $make("sysquery.lvm.VolumeGroup", { name: volume.volumeGroup });
						}
					}
				}
			});
		}
	}
};