package com.ximple.eofms.util;

/**
 *
 * TODO Purpose of
 * <p>
 *
 * </p>
 * @author Ulysses
 * @since 1.1.0
 */
public enum ConnectivityDirectionEnum {
	Noneflow((short) 0),

	ForwardflowON((short) 0x01),

	BackflowON((short) 0x02),

	ForwardflowOFF((short) 0x03),

	BackflowOFF((short) 0x04),

	ForwardFixflowON((short) 0x05),

	ForwardFixflowOFF((short) 0x06),

	BackFixflowON((short) 0x07),

	BackFixflowOFF((short) 0x08),

	Breakflow((short) 0x62),

	Nondeterminate((short) 0x63),

	PhaseAON((short) 0x64), // 100

	PhaseBON((short) 0xC8), // 200

	PhaseCON((short) 0x190); // 400

	private final short value;

	ConnectivityDirectionEnum(short value) {
		this.value = value;
	}

	public short getValue() {
		return this.value;
	}

	public static ConnectivityDirectionEnum convertShort(short val) {
		if (val == 0)
			return Noneflow;
		if (val == 0x1)
			return ForwardflowON;
		if (val == 0x2)
			return BackflowON;
		if (val == 0x3)
			return ForwardflowOFF;
		if (val == 0x4)
			return BackflowOFF;
		if (val == 0x5)
			return ForwardFixflowON;
		if (val == 0x6)
			return ForwardFixflowOFF;
		if (val == 0x7)
			return BackFixflowON;
		if (val == 0x8)
			return BackFixflowOFF;
		if (val == 0x62)
			return Breakflow;
		return Nondeterminate;
	}

	public static boolean isOn(short val) {
		short dir = (short) (val & 0x00ff);
		switch (dir) {
		case 0x0:
		case 0x1:
		case 0x2:
		case 0x5:
		case 0x7:
			return true;
		}

		return false;
	}

	public static boolean isOff(short val) {
		return (!isOn(val));
	}

	public static boolean isForward(short val) {
		short dir = (short) (val & 0x00ff);
		switch (dir) {
		case 0x1:
		case 0x3:
		case 0x5:
		case 0x6:
			return true;
		}

		return false;
	}

	public static boolean isBackward(short val) {
		short dir = (short) (val & 0x00ff);
		switch (dir) {
		case 0x2:
		case 0x4:
		case 0x7:
		case 0x8:
			return true;
		}

		return false;
	}

	public static boolean isFixDirection(short val) {
		short dir = (short) (val & 0x00ff);
		switch (dir) {
		case 0x5:
		case 0x6:
		case 0x7:
		case 0x8:
			return true;
		}

		return false;
	}

	public static boolean isNondeterminate(short val) {
		short dir = (short) (val & 0x00ff);
		return (dir == 0x63);
	}

	public static short getWeight(short val) {
		short weight = (short) (val & 0xff00);
		return (short) (weight >>> 8);
	}

	@Override
    public String toString() {
		boolean isA = (this.value & PhaseAON.getValue()) != 0;
		boolean isB = (this.value & PhaseBON.getValue()) != 0;
		boolean isC = (this.value & PhaseCON.getValue()) != 0;
		String phase = "" + (isA ? "A" : "") + (isB ? "B" : "") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				+ (isC ? "C" : ""); //$NON-NLS-1$ //$NON-NLS-2$
		if (phase.length() != 0)
			phase = "[" + phase + "]"; //$NON-NLS-1$ //$NON-NLS-2$

		if (value == 0)
			return "Noneflow" + phase; //$NON-NLS-1$
		if (value == 0x1)
			return "ForwardflowON" + phase; //$NON-NLS-1$
		if (value == 0x2)
			return "BackflowON" + phase; //$NON-NLS-1$
		if (value == 0x3)
			return "ForwardflowOFF" + phase; //$NON-NLS-1$
		if (value == 0x4)
			return "BackflowOFF" + phase; //$NON-NLS-1$
		if (value == 0x5)
			return "ForwardFixflowON" + phase; //$NON-NLS-1$
		if (value == 0x6)
			return "ForwardFixflowOFF" + phase; //$NON-NLS-1$
		if (value == 0x7)
			return "BackFixflowON" + phase; //$NON-NLS-1$
		if (value == 0x8)
			return "BackFixflowOFF" + phase; //$NON-NLS-1$
		if (value == 0x62)
			return "Breakflow" + phase; //$NON-NLS-1$
		return "Nondeterminate"; //$NON-NLS-1$
	}

	/*
	 *
	 * enum DirectionType { Noneflow = 0, ForwardflowON = 0x01, BackflowON =
	 * 0x02, ForwardflowOFF = 0x03, BackflowOFF = 0x04, ForwardFixflowON = 0x05,
	 * ForwardFixflowOFF = 0x06, BackFixflowON = 0x07, BackFixflowOFF = 0x08,
	 * Breakflow = 0x62, Nondeterminate = 0x63, PhaseAON = 0x64, // 100 PhaseBON
	 * = 0xC8, // 200 PhaseCON = 0x190 // 400 };
	 *
	 * enum OperationType { OFF = 0, ON = 0x01, NSTATUS = 0x10 };
	 *
	 *
	 * enum tagNetworkEdgeFlowType { FLOWUNKNOWN = 0x0000, // "???w" FLOWFORWARD
	 * = 0x0001, // "???V" FLOWBACKWARD = 0x0002, // "�Xf?V" FLOWTWOWAY =
	 * 0x0003, // "???V" FLOWBREAK = 0x00F0, // "???_" FLOWUNDELEGATED = 0x00FF,
	 * // "?L�PN?q"
	 *
	 * FLOWWT_1 = 0x0100, // A FLOWWT_2 = 0x0200, // B FLOWWT_3 = 0x0400, // C
	 * FLOWWT_4 = 0x0800, // ?-Unused
	 *
	 * FLOWON = 0x1000, // "On" FLOWOFF = 0x0000, // "Off"
	 *
	 * FLOWFIX = 0x2000, // Fix Dir
	 *
	 * FLOWONMASK = 0xF000, FLOWWTMASK = 0x0F00, FLOWWAYMASK = 0x00FF };
	 *
	 * enum tagNetworkEdgeOStatusType { OPSTATUS_OFF = 0x0000, OPSTATUS_ON =
	 * 0x0001, BOUNDSTATUS = 0x0010, OPSTATUSMASK = 0x000F };
	 *
	 * enum tagPhaseMask { PhaseUnknown = 0x0, PhaseA = 0x1, PhaseB = 0x2,
	 * PhaseC = 0x4, PhaseN = 0x8 };
	 *
	 * BYTE CNetworkSnapshot::marshalDIRFromDirection(short wFlag) { // BYTE
	 * bRet = 0xFF; bool bON; bool bFix; if ((wFlag & CNetworkEdge::FLOWONMASK)
	 * == CNetworkEdge::FLOWON) bON = true; else bON = false; if ((wFlag &
	 * CNetworkEdge::FLOWONMASK) == CNetworkEdge::FLOWFIX) bFix = true; else
	 * bFix = false;
	 *
	 * switch (wFlag & CNetworkEdge::FLOWWAYMASK) { case
	 * CNetworkEdge::FLOWFORWARD: if (bFix) if (bON) return
	 * CFacility::ForwardFixflowON ; else return CFacility::ForwardFixflowOFF;
	 * else if (bON) return CFacility::ForwardflowON; else return
	 * CFacility::ForwardflowOFF;
	 *
	 * case CNetworkEdge::FLOWBACKWARD: if (bFix) if (bON) return
	 * CFacility::BackFixflowON; else return CFacility::BackFixflowOFF; else if
	 * (bON) return CFacility::BackflowON; else return CFacility::BackflowOFF;
	 *
	 * case CNetworkEdge::FLOWUNKNOWN: case CNetworkEdge::FLOWTWOWAY: return
	 * CFacility::Noneflow;
	 *
	 * case CNetworkEdge::FLOWBREAK: return CFacility::Breakflow;
	 *
	 * case CNetworkEdge::FLOWUNDELEGATED: return CFacility::Nondeterminate;
	 *
	 * default: break; }
	 *
	 * return 0xFF; }
	 *
	 * short CNetworkSnapshot::marshalDirectionFromDIR(WORD bFlag) { short wRet
	 * = CNetworkEdge::FLOWUNDELEGATED; switch (bFlag) { case
	 * CFacility::Noneflow: wRet = CNetworkEdge::FLOWUNKNOWN; break; case
	 * CFacility::ForwardflowON: wRet = CNetworkEdge::FLOWFORWARD |
	 * CNetworkEdge::FLOWON; break; case CFacility::BackflowON: wRet =
	 * CNetworkEdge::FLOWBACKWARD | CNetworkEdge::FLOWON; break; case
	 * CFacility::ForwardflowOFF: wRet = CNetworkEdge::FLOWFORWARD; break; case
	 * CFacility::BackflowOFF: wRet = CNetworkEdge::FLOWBACKWARD; break; case
	 * CFacility::ForwardFixflowON: wRet = CNetworkEdge::FLOWFORWARD |
	 * CNetworkEdge::FLOWON | CNetworkEdge::FLOWFIX; break; case
	 * CFacility::ForwardFixflowOFF: wRet = CNetworkEdge::FLOWFORWARD |
	 * CNetworkEdge::FLOWFIX; break; case CFacility::BackFixflowON: wRet =
	 * CNetworkEdge::FLOWBACKWARD | CNetworkEdge::FLOWON |
	 * CNetworkEdge::FLOWFIX; break; case CFacility::BackFixflowOFF: wRet =
	 * CNetworkEdge::FLOWBACKWARD | CNetworkEdge::FLOWFIX; break; case
	 * CFacility::Breakflow: wRet = CNetworkEdge::FLOWBREAK; break; case
	 * CFacility::Nondeterminate: wRet = CNetworkEdge::FLOWUNDELEGATED; break;
	 * default: break; } return wRet; }
	 *
	 * short CNetworkSnapshot::marshalPhaseToMask(short wPhase) { short
	 * wMaskValue = 0;
	 *
	 * if (wPhase == 1) { wMaskValue |= CNetworkEdge::PhaseA |
	 * CNetworkEdge::PhaseB | CNetworkEdge::PhaseC; return wMaskValue; }
	 *
	 * if (wPhase > 16) { wMaskValue = CNetworkEdge::PhaseN; wPhase -= 16; }
	 *
	 * if (wPhase > 10) { wMaskValue |= CNetworkEdge::PhaseA |
	 * CNetworkEdge::PhaseB | CNetworkEdge::PhaseC; return wMaskValue; }
	 *
	 * switch (wPhase) { case 5: // AB case 6: // BA wMaskValue |=
	 * CNetworkEdge::PhaseA | CNetworkEdge::PhaseB; break; case 7: // BC case 8:
	 * // CB wMaskValue |= CNetworkEdge::PhaseB | CNetworkEdge::PhaseC; break;
	 * case 9: // CA case 10: // AC wMaskValue |= CNetworkEdge::PhaseA |
	 * CNetworkEdge::PhaseC; break; case 2: // A wMaskValue |=
	 * CNetworkEdge::PhaseA; break; case 3: // B wMaskValue |=
	 * CNetworkEdge::PhaseB; break; case 4: // C wMaskValue |=
	 * CNetworkEdge::PhaseC; break; default: wMaskValue |=
	 * CNetworkEdge::PhaseUnknown; break; }
	 *
	 * return wMaskValue; }
	 */
}