/*
 * Copyright (C) 2013, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef LATINIME_PT_NODE_PARAMS_H
#define LATINIME_PT_NODE_PARAMS_H

#include <cstring>

#include "defines.h"
#include "dictionary/structure/pt_common/dynamic_pt_reading_utils.h"
#include "dictionary/structure/pt_common/patricia_trie_reading_utils.h"
#include "dictionary/structure/v4/ver4_dict_constants.h"
#include "utils/char_utils.h"
#include "utils/int_array_view.h"

namespace latinime {

// This class has information of a PtNode. This class is immutable.
class PtNodeParams {
 public:
    // Invalid PtNode.
    PtNodeParams() : mHeadPos(NOT_A_DICT_POS), mFlags(0), mHasMovedFlag(false),
            mParentPos(NOT_A_DICT_POS), mCodePointCount(0), mCodePoints(),
            mTerminalIdFieldPos(NOT_A_DICT_POS), mTerminalId(Ver4DictConstants::NOT_A_TERMINAL_ID),
            mProbabilityFieldPos(NOT_A_DICT_POS), mProbability(NOT_A_PROBABILITY),
            mChildrenPosFieldPos(NOT_A_DICT_POS), mChildrenPos(NOT_A_DICT_POS),
            mBigramLinkedNodePos(NOT_A_DICT_POS), mShortcutPos(NOT_A_DICT_POS),
            mBigramPos(NOT_A_DICT_POS), mSiblingPos(NOT_A_DICT_POS) {}

    PtNodeParams(const PtNodeParams& ptNodeParams)
            : mHeadPos(ptNodeParams.mHeadPos), mFlags(ptNodeParams.mFlags),
              mHasMovedFlag(ptNodeParams.mHasMovedFlag), mParentPos(ptNodeParams.mParentPos),
              mCodePointCount(ptNodeParams.mCodePointCount), mCodePoints(),
              mTerminalIdFieldPos(ptNodeParams.mTerminalIdFieldPos),
              mTerminalId(ptNodeParams.mTerminalId),
              mProbabilityFieldPos(ptNodeParams.mProbabilityFieldPos),
              mProbability(ptNodeParams.mProbability),
              mChildrenPosFieldPos(ptNodeParams.mChildrenPosFieldPos),
              mChildrenPos(ptNodeParams.mChildrenPos),
              mBigramLinkedNodePos(ptNodeParams.mBigramLinkedNodePos),
              mShortcutPos(ptNodeParams.mShortcutPos), mBigramPos(ptNodeParams.mBigramPos),
              mSiblingPos(ptNodeParams.mSiblingPos) {
        memcpy(mCodePoints, ptNodeParams.getCodePoints(), sizeof(int) * mCodePointCount);
    }

    // PtNode read from version 2 dictionary.
    PtNodeParams(const int headPos, const PatriciaTrieReadingUtils::NodeFlags flags,
            const int codePointCount, const int *const codePoints, const int probability,
            const int childrenPos, const int shortcutPos, const int bigramPos,
            const int siblingPos)
            : mHeadPos(headPos), mFlags(flags), mHasMovedFlag(false), mParentPos(NOT_A_DICT_POS),
              mCodePointCount(codePointCount), mCodePoints(), mTerminalIdFieldPos(NOT_A_DICT_POS),
              mTerminalId(Ver4DictConstants::NOT_A_TERMINAL_ID),
              mProbabilityFieldPos(NOT_A_DICT_POS), mProbability(probability),
              mChildrenPosFieldPos(NOT_A_DICT_POS), mChildrenPos(childrenPos),
              mBigramLinkedNodePos(NOT_A_DICT_POS), mShortcutPos(shortcutPos),
              mBigramPos(bigramPos), mSiblingPos(siblingPos) {
        memcpy(mCodePoints, codePoints, sizeof(int) * mCodePointCount);
    }

    // PtNode with a terminal id.
    PtNodeParams(const int headPos, const PatriciaTrieReadingUtils::NodeFlags flags,
            const int parentPos, const int codePointCount, const int *const codePoints,
            const int terminalIdFieldPos, const int terminalId, const int probability,
            const int childrenPosFieldPos, const int childrenPos, const int siblingPos)
            : mHeadPos(headPos), mFlags(flags), mHasMovedFlag(true), mParentPos(parentPos),
              mCodePointCount(codePointCount), mCodePoints(),
              mTerminalIdFieldPos(terminalIdFieldPos), mTerminalId(terminalId),
              mProbabilityFieldPos(NOT_A_DICT_POS), mProbability(probability),
              mChildrenPosFieldPos(childrenPosFieldPos), mChildrenPos(childrenPos),
              mBigramLinkedNodePos(NOT_A_DICT_POS), mShortcutPos(terminalId),
              mBigramPos(terminalId), mSiblingPos(siblingPos) {
        memcpy(mCodePoints, codePoints, sizeof(int) * mCodePointCount);
    }

    // Construct new params by updating existing PtNode params.
    PtNodeParams(const PtNodeParams *const ptNodeParams,
            const PatriciaTrieReadingUtils::NodeFlags flags, const int parentPos,
            const CodePointArrayView codePoints, const int probability)
            : mHeadPos(ptNodeParams->getHeadPos()), mFlags(flags), mHasMovedFlag(true),
              mParentPos(parentPos), mCodePointCount(codePoints.size()), mCodePoints(),
              mTerminalIdFieldPos(ptNodeParams->getTerminalIdFieldPos()),
              mTerminalId(ptNodeParams->getTerminalId()),
              mProbabilityFieldPos(ptNodeParams->getProbabilityFieldPos()),
              mProbability(probability),
              mChildrenPosFieldPos(ptNodeParams->getChildrenPosFieldPos()),
              mChildrenPos(ptNodeParams->getChildrenPos()),
              mBigramLinkedNodePos(ptNodeParams->getBigramLinkedNodePos()),
              mShortcutPos(ptNodeParams->getShortcutPos()),
              mBigramPos(ptNodeParams->getBigramsPos()),
              mSiblingPos(ptNodeParams->getSiblingNodePos()) {
        memcpy(mCodePoints, codePoints.data(), sizeof(int) * mCodePointCount);
    }

    PtNodeParams(const PatriciaTrieReadingUtils::NodeFlags flags, const int parentPos,
            const CodePointArrayView codePoints, const int probability)
            : mHeadPos(NOT_A_DICT_POS), mFlags(flags), mHasMovedFlag(true), mParentPos(parentPos),
              mCodePointCount(codePoints.size()), mCodePoints(),
              mTerminalIdFieldPos(NOT_A_DICT_POS),
              mTerminalId(Ver4DictConstants::NOT_A_TERMINAL_ID),
              mProbabilityFieldPos(NOT_A_DICT_POS), mProbability(probability),
              mChildrenPosFieldPos(NOT_A_DICT_POS), mChildrenPos(NOT_A_DICT_POS),
              mBigramLinkedNodePos(NOT_A_DICT_POS), mShortcutPos(NOT_A_DICT_POS),
              mBigramPos(NOT_A_DICT_POS), mSiblingPos(NOT_A_DICT_POS) {
        memcpy(mCodePoints, codePoints.data(), sizeof(int) * mCodePointCount);
    }

    AK_FORCE_INLINE bool isValid() const {
        return mCodePointCount > 0;
    }

    // Head position of the PtNode
    AK_FORCE_INLINE int getHeadPos() const {
        return mHeadPos;
    }

    // Flags
    AK_FORCE_INLINE bool isDeleted() const {
        return mHasMovedFlag && DynamicPtReadingUtils::isDeleted(mFlags);
    }

    AK_FORCE_INLINE bool willBecomeNonTerminal() const {
        return mHasMovedFlag && DynamicPtReadingUtils::willBecomeNonTerminal(mFlags);
    }

    AK_FORCE_INLINE bool hasChildren() const {
        return mChildrenPos != NOT_A_DICT_POS;
    }

    AK_FORCE_INLINE bool isTerminal() const {
        return PatriciaTrieReadingUtils::isTerminal(mFlags);
    }

    AK_FORCE_INLINE bool isPossiblyOffensive() const {
        return PatriciaTrieReadingUtils::isPossiblyOffensive(mFlags);
    }

    AK_FORCE_INLINE bool isNotAWord() const {
        return PatriciaTrieReadingUtils::isNotAWord(mFlags);
    }

    AK_FORCE_INLINE bool hasBigrams() const {
        return PatriciaTrieReadingUtils::hasBigrams(mFlags);
    }

    AK_FORCE_INLINE bool hasShortcutTargets() const {
        return PatriciaTrieReadingUtils::hasShortcutTargets(mFlags);
    }

    AK_FORCE_INLINE bool representsNonWordInfo() const {
        return getCodePointCount() > 0 && !CharUtils::isInUnicodeSpace(getCodePoints()[0])
                && isNotAWord();
    }

    AK_FORCE_INLINE int representsBeginningOfSentence() const {
        return getCodePointCount() > 0 && getCodePoints()[0] == CODE_POINT_BEGINNING_OF_SENTENCE
                && isNotAWord();
    }

    // Parent node position
    AK_FORCE_INLINE int getParentPos() const {
        return mParentPos;
    }

    AK_FORCE_INLINE const CodePointArrayView getCodePointArrayView() const {
        return CodePointArrayView(mCodePoints, mCodePointCount);
    }

    // TODO: Remove
    // Number of code points
    AK_FORCE_INLINE uint8_t getCodePointCount() const {
        return mCodePointCount;
    }

    // TODO: Remove
    AK_FORCE_INLINE const int *getCodePoints() const {
        return mCodePoints;
    }

    // Probability
    AK_FORCE_INLINE int getTerminalIdFieldPos() const {
        return mTerminalIdFieldPos;
    }

    AK_FORCE_INLINE int getTerminalId() const {
        return mTerminalId;
    }

    // Probability
    AK_FORCE_INLINE int getProbabilityFieldPos() const {
        return mProbabilityFieldPos;
    }

    AK_FORCE_INLINE int getProbability() const {
        return mProbability;
    }

    // Children PtNode array position
    AK_FORCE_INLINE int getChildrenPosFieldPos() const {
        return mChildrenPosFieldPos;
    }

    AK_FORCE_INLINE int getChildrenPos() const {
        return mChildrenPos;
    }

    // Bigram linked node position.
    AK_FORCE_INLINE int getBigramLinkedNodePos() const {
        return mBigramLinkedNodePos;
    }

    // Shortcutlist position
    AK_FORCE_INLINE int getShortcutPos() const {
        return mShortcutPos;
    }

    // Bigrams position
    AK_FORCE_INLINE int getBigramsPos() const {
        return mBigramPos;
    }

    // Sibling node position
    AK_FORCE_INLINE int getSiblingNodePos() const {
        return mSiblingPos;
    }

 private:
    // This class have a public copy constructor to be used as a return value.
    DISALLOW_ASSIGNMENT_OPERATOR(PtNodeParams);

    const int mHeadPos;
    const PatriciaTrieReadingUtils::NodeFlags mFlags;
    const bool mHasMovedFlag;
    const int mParentPos;
    const uint8_t mCodePointCount;
    int mCodePoints[MAX_WORD_LENGTH];
    const int mTerminalIdFieldPos;
    const int mTerminalId;
    const int mProbabilityFieldPos;
    const int mProbability;
    const int mChildrenPosFieldPos;
    const int mChildrenPos;
    const int mBigramLinkedNodePos;
    const int mShortcutPos;
    const int mBigramPos;
    const int mSiblingPos;
};
} // namespace latinime
#endif /* LATINIME_PT_NODE_PARAMS_H */