Expresiones lógicas

("factura" or "reclamación") and ("cliente") and not ("pedido" or "albarán")

(1 or 0) and (1) and not (0 or 0)

(1) and 1 and not (0)
1 and 1 and not 0
1 and 1
1

/// <summary>
///		Motor de ejecución de fórmulas
/// </summary>
public class Interpreter
{
	/// <summary>
	///		Ejecuta una fórmula comprobando una cadena
	/// </summary>
	public bool Execute(string formula, string source, char quote = '"')
	{
		string result = string.Empty;

			// 1. Normaliza la fórmula y el origen: quita los saltos de línea, tabuladores y los espacios dobles
			formula = Normalize(formula);
			source = Normalize(source);
			// 2. Si realmente nos queda algo por analizar
			if (!string.IsNullOrWhiteSpace(formula) && !string.IsNullOrWhiteSpace(source))
			{
				// 2.1. Comprueba si las cadenas de la regla (formula) están el valor buscado (source) y las reemplaza por 0s y 1s
				result = CheckStringsAtSource(formula.ToLower(), source.ToLower(), quote);
				// 2.2. Interpreta las condiciones
				result = Parse(result);
			}
			// 3. Normaliza el resultado
			if (string.IsNullOrWhiteSpace(result))
				result = "0";
			else
				result = result.Trim();
			// 4. Devuelve el valor que indica si se ha ejecutado correctamente
			return result.Equals("1");
	}

	/// <summary>
	///		Normaliza una cadena: quita saltos de línea y espacios dobles
	/// </summary>
	private string Normalize(string value)
	{
		string[] skipChars = ["\r", "\n", "\t", "  "];
		bool replaced;

			// Quita los caracteres extraños: saltos de línea, tabuladores, dobles espacios
			do
			{
				// Indica que por ahora no se ha reemplazado nada
				replaced = false;
				// Reemplaza los caracteres especificados
				foreach (string skipChar in skipChars)
					if (!string.IsNullOrWhiteSpace(value) && value.IndexOf(skipChar) >= 0)
					{
						// Reemplaza el valor
						value = value.Replace(skipChar, " ");
						// Indica que se ha reemplazado el valor
						replaced = true;
					}
			}
			while (!string.IsNullOrWhiteSpace(value) && replaced);
			// Devuelve la cadena normalizada
			return value;
	}

	/// <summary>
	///		Comprueba si las cadenas de la fórmula (lo que haya entre comillas), se encuentran en la cadena de origen.
	///		Si una cadena está en el origen, la cambia por 1, si no, la cambia por 0
	/// </summary>
	private string CheckStringsAtSource(string formula, string source, char quote)
	{
		string result = string.Empty, readedString = string.Empty;
		bool atQuotes = false;
		char previousChar = '#';

			// Recorre los caracteres buscando lo que haya entre comillas
			for (int index = 0; index < formula.Length; index++)
			{
				char actualChar = formula[index];

					// Si estamos en una cadena, guardamos hasta que encontremos el final de la cadena
					if (atQuotes)
					{
						if (actualChar == quote && previousChar != '\\') // ... si estamos entre comillas, la siguiente comilla cierra la cadena a menos que el carácter anterior sea \
						{
							// Comprobamos si la cadena está en el origen
							if (string.IsNullOrWhiteSpace(readedString) || source.IndexOf(readedString) >= 0) // ... si la cadena buscada está en el origen
								result += "1";
							else
								result += "0";
							// Ya no estamos entre comillas
							atQuotes = false;
							readedString = string.Empty;
						}
						else // estamos entre comillas y por tanto guardamos este carácter
							readedString += actualChar;
					}
					else if (actualChar == quote) // ... si encontramos una comilla, es porque se arranca una cadena
						atQuotes = true;
					else // ... estamos fuera de las comillas, guardamos la cadena en el resultado
						result += actualChar;
					// Guarda el carácter anterior
					previousChar = actualChar;
			}
			// Devuelve la cadena resultante (que ya sólo debe estar formadas por 1s y 0s, operadores lógicos y paréntesis)
			return result;
	}

	/// <summary>
	///		Interpreta la fórmula: la fórmula debería ser una cadena del tipo "(1 or 0) and (not 1 or 0)", es decir, 1s y 0s, operadores
	///	de relación y paréntesis
	/// </summary>
	private string Parse(string formula)
	{
		int loops = 0;

			// Normaliza la cadena (no debería haber saltos pero sí que puede que tengamos espacios dobles)
			formula = Normalize(formula);
			// Interpretamos la cadena
			while (!string.IsNullOrWhiteSpace(formula) &&  formula.Length > 1 && loops < 1_000)
			{
				// Quita los paréntesis que hayan podido quedar con espacios
				formula = formula.Replace("( ", "(");
				formula = formula.Replace(" )", ")");
				// Calcula los OR
				formula = formula.Replace("1 or 1", "1");
				formula = formula.Replace("0 or 1", "1");
				formula = formula.Replace("1 or 0", "1");
				formula = formula.Replace("0 or 0", "0");
				// Calcula los AND
				formula = formula.Replace("1 and 1", "1");
				formula = formula.Replace("0 and 1", "0");
				formula = formula.Replace("1 and 0", "0");
				formula = formula.Replace("0 and 0", "0");
				// Calcula los NOT
				formula = formula.Replace("not 1", "0");
				formula = formula.Replace("not 0", "1");
				// Calcula los paréntesis
				formula = formula.Replace("(0)", "0");
				formula = formula.Replace("(1)", "1");
				// Incrementamos el número de bucles (para no complicarnos demasiado, suponemos que más de 1.000 pasos por el bucle es porque hay error)
				loops++;
			}
			// Devuelve la cadena
			return formula;
	}
}