/**
 * @fileoverview Disallow Labeled Statements
 * @author Nicholas C. Zakas
 */
"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const astUtils = require("./utils/ast-utils");

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('../shared/types').Rule} */
module.exports = {
	meta: {
		type: "suggestion",

		defaultOptions: [
			{
				allowLoop: false,
				allowSwitch: false,
			},
		],

		docs: {
			description: "Disallow labeled statements",
			recommended: false,
			frozen: true,
			url: "https://eslint.org/docs/latest/rules/no-labels",
		},

		schema: [
			{
				type: "object",
				properties: {
					allowLoop: {
						type: "boolean",
					},
					allowSwitch: {
						type: "boolean",
					},
				},
				additionalProperties: false,
			},
		],

		messages: {
			unexpectedLabel: "Unexpected labeled statement.",
			unexpectedLabelInBreak: "Unexpected label in break statement.",
			unexpectedLabelInContinue:
				"Unexpected label in continue statement.",
		},
	},

	create(context) {
		const [{ allowLoop, allowSwitch }] = context.options;
		let scopeInfo = null;

		/**
		 * Gets the kind of a given node.
		 * @param {ASTNode} node A node to get.
		 * @returns {string} The kind of the node.
		 */
		function getBodyKind(node) {
			if (astUtils.isLoop(node)) {
				return "loop";
			}
			if (node.type === "SwitchStatement") {
				return "switch";
			}
			return "other";
		}

		/**
		 * Checks whether the label of a given kind is allowed or not.
		 * @param {string} kind A kind to check.
		 * @returns {boolean} `true` if the kind is allowed.
		 */
		function isAllowed(kind) {
			switch (kind) {
				case "loop":
					return allowLoop;
				case "switch":
					return allowSwitch;
				default:
					return false;
			}
		}

		/**
		 * Checks whether a given name is a label of a loop or not.
		 * @param {string} label A name of a label to check.
		 * @returns {boolean} `true` if the name is a label of a loop.
		 */
		function getKind(label) {
			let info = scopeInfo;

			while (info) {
				if (info.label === label) {
					return info.kind;
				}
				info = info.upper;
			}

			/* c8 ignore next */
			return "other";
		}

		//--------------------------------------------------------------------------
		// Public
		//--------------------------------------------------------------------------

		return {
			LabeledStatement(node) {
				scopeInfo = {
					label: node.label.name,
					kind: getBodyKind(node.body),
					upper: scopeInfo,
				};
			},

			"LabeledStatement:exit"(node) {
				if (!isAllowed(scopeInfo.kind)) {
					context.report({
						node,
						messageId: "unexpectedLabel",
					});
				}

				scopeInfo = scopeInfo.upper;
			},

			BreakStatement(node) {
				if (node.label && !isAllowed(getKind(node.label.name))) {
					context.report({
						node,
						messageId: "unexpectedLabelInBreak",
					});
				}
			},

			ContinueStatement(node) {
				if (node.label && !isAllowed(getKind(node.label.name))) {
					context.report({
						node,
						messageId: "unexpectedLabelInContinue",
					});
				}
			},
		};
	},
};
