void StandardCalculatorViewModel::SaveEditedCommand()

in src/CalcViewModel/StandardCalculatorViewModel.cpp [1281:1378]
90 lines of code
21 McCabe index (conditional complexity)

void StandardCalculatorViewModel::SaveEditedCommand(_In_ unsigned int tokenPosition, _In_ Command command)
{
    bool handleOperand = false;
    wstring updatedToken;

    const pair<wstring, int>& token = m_tokens->at(tokenPosition);
    const shared_ptr<IExpressionCommand>& tokenCommand = m_commands->at(token.second);

    if (IsUnaryOp(command) && command != Command::CommandSIGN)
    {
        int angleCmd = static_cast<int>(m_standardCalculatorManager.GetCurrentDegreeMode());
        AngleType angleType = GetAngleTypeFromCommand(static_cast<Command>(angleCmd));

        if (IsTrigOp(command))
        {
            shared_ptr<IUnaryCommand> spUnaryCommand = dynamic_pointer_cast<IUnaryCommand>(tokenCommand);
            spUnaryCommand->SetCommands(angleCmd, static_cast<int>(command));
        }
        else
        {
            shared_ptr<IUnaryCommand> spUnaryCommand = dynamic_pointer_cast<IUnaryCommand>(tokenCommand);
            spUnaryCommand->SetCommand(static_cast<int>(command));
        }

        switch (command)
        {
        case Command::CommandASIN:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(Command::CommandSIN), true, angleType);
            break;
        case Command::CommandACOS:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(Command::CommandCOS), true, angleType);
            break;
        case Command::CommandATAN:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(Command::CommandTAN), true, angleType);
            break;
        case Command::CommandASINH:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(Command::CommandSINH), true, angleType);
            break;
        case Command::CommandACOSH:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(Command::CommandCOSH), true, angleType);
            break;
        case Command::CommandATANH:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(Command::CommandTANH), true, angleType);
            break;
        case Command::CommandPOWE:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(Command::CommandLN), true, angleType);
            break;
        default:
            updatedToken = CCalcEngine::OpCodeToUnaryString(static_cast<int>(command), false, angleType);
        }
        if ((token.first.length() > 0) && (token.first[token.first.length() - 1] == L'('))
        {
            updatedToken += L'(';
        }
    }
    else if (IsBinOp(command))
    {
        shared_ptr<IBinaryCommand> spBinaryCommand = dynamic_pointer_cast<IBinaryCommand>(tokenCommand);
        spBinaryCommand->SetCommand(static_cast<int>(command));
        updatedToken = CCalcEngine::OpCodeToString(static_cast<int>(command));
    }
    else if (IsOpnd(command) || command == Command::CommandBACK)
    {
        HandleUpdatedOperandData(command);
        handleOperand = true;
    }
    else if (command == Command::CommandSIGN)
    {
        if (tokenCommand->GetCommandType() == CommandType::UnaryCommand)
        {
            shared_ptr<IExpressionCommand> spSignCommand = make_shared<CUnaryCommand>(static_cast<int>(command));
            m_commands->insert(m_commands->begin() + token.second + 1, spSignCommand);
        }
        else
        {
            shared_ptr<IOpndCommand> spOpndCommand = dynamic_pointer_cast<IOpndCommand>(tokenCommand);
            spOpndCommand->ToggleSign();
            updatedToken = spOpndCommand->GetToken(m_standardCalculatorManager.DecimalSeparator());
        }
        IsOperandUpdatedUsingViewModel = true;
    }

    if (!handleOperand)
    {
        (*m_commands)[token.second] = tokenCommand;
        (*m_tokens)[tokenPosition].first = updatedToken;

        DisplayExpressionToken ^ displayExpressionToken = ExpressionTokens->GetAt(tokenPosition);
        displayExpressionToken->Token = ref new Platform::String(updatedToken.c_str());

        // Special casing
        if (command == Command::CommandSIGN && tokenCommand->GetCommandType() == CommandType::UnaryCommand)
        {
            IsEditingEnabled = false;
            Recalculate();
        }
    }
}