#ifndef __PRSONA_SERVER_HPP
#define __PRSONA_SERVER_HPP

#include <vector>

#include "BGN.hpp"
#include "Curvepoint.hpp"
#include "Bipoint.hpp"

#include "base.hpp"
#include "EGCiphertext.hpp"
#include "proof.hpp"

class PrsonaServer : public PrsonaBase {
    public:
        // CONSTRUCTORS
        PrsonaServer(size_t numServers);
        PrsonaServer(size_t numServers, const BGN& other_bgn);

        // BASIC PUBLIC SYSTEM INFO GETTERS
        BGNPublicKey get_bgn_public_key() const;
        size_t get_num_clients() const;
        size_t get_num_servers() const;
        
        // FRESH GENERATOR CALCULATION
        Curvepoint add_curr_seed_to_generator(
            std::vector<Proof>& pi,
            const Curvepoint& currGenerator) const;
        Curvepoint add_next_seed_to_generator(
            std::vector<Proof>& pi,
            const Curvepoint& currGenerator) const;

        // ENCRYPTED DATA GETTERS
        std::vector<CurveBipoint> get_current_votes_by(
            Proof& pi, const Curvepoint& shortTermPublicKey) const;
        std::vector<std::vector<CurveBipoint>> get_all_current_votes(
            Proof& pi) const;
        EGCiphertext get_current_user_encrypted_tally(
            Proof& pi, const Curvepoint& shortTermPublicKey) const;
        TwistBipoint get_current_server_encrypted_tally(
            Proof& pi, const Curvepoint& shortTermPublicKey) const;
        std::vector<Curvepoint> get_current_pseudonyms(Proof& pi) const;

        // CLIENT INTERACTIONS
        void add_new_client(
            std::vector<Proof>& proofOfValidAddition,
            const Proof& proofOfValidKey,
            const Curvepoint& shortTermPublicKey);
        bool receive_vote(
            const std::vector<Proof>& pi,
            const std::vector<CurveBipoint>& newVotes,
            const Curvepoint& shortTermPublicKey);

    private:
        // constants for servers
        const size_t numServers;

        // Identical between all servers (but collaboratively constructed)
        BGN bgnSystem;

        // Private; different for each server
        Scalar currentSeed;
        Scalar nextSeed;

        // The actual data, which is collaboratively updated by all servers
        Curvepoint currentFreshGenerator;
        std::vector<TwistBipoint> previousVoteTallies;
        std::vector<Curvepoint> currentPseudonyms;
        std::vector<EGCiphertext> currentUserEncryptedTallies;
        std::vector<std::vector<CurveBipoint>> voteMatrix;

        /**
         * NOTE: voteMatrix structure:
         * Each element represents a vote by <rowID> applied to <colID>.
         * The outer vector is a vector of rows and the inner vector is
         * a vector of encrypted votes.
         */

        // An imaginary class; it's just used right now to coordinate servers
        // in memory instead of via network action.
        friend class PrsonaServerEntity;

        // CONSTRUCTOR HELPERS
        const BGN& get_bgn_details() const;
        bool initialize_fresh_generator(
            const std::vector<Proof>& pi,
            const Curvepoint& firstGenerator);
        Curvepoint add_rand_seed_to_generator(
            std::vector<Proof>& pi,
            const Curvepoint& currGenerator) const;
        bool set_EG_blind_generator(
            const std::vector<Proof>& pi,
            const Curvepoint& currGenerator);
        
        // SCORE TALLYING
        std::vector<Scalar> tally_scores();
        Scalar get_max_possible_score(Proof& pi);
        
        // EPOCH ROUNDS
        void build_up_midway_pseudonyms(
            Proof& pi, Curvepoint& nextGenerator);
        void break_down_midway_pseudonyms(
            Proof& pi, const Curvepoint& nextGenerator);

        // DATA MAINTENANCE
        void import_updates(
            const Proof& pi,
            const std::vector<TwistBipoint>& otherPreviousVoteTally,
            const std::vector<Curvepoint>& otherCurrentPseudonyms,
            const std::vector<EGCiphertext>& otherCurrentUserEncryptedTallies,
            const std::vector<std::vector<CurveBipoint>>& otherVoteMatrix
        );
        void export_updates(
            std::vector<TwistBipoint>& otherPreviousVoteTally,
            std::vector<Curvepoint>& otherCurrentPseudonyms,
            std::vector<EGCiphertext>& otherCurrentUserEncryptedTallies,
            std::vector<std::vector<CurveBipoint>>& otherVoteMatrix
        ) const;

        // DATA SAFEKEEPING
        void rerandomize_data();
        std::vector<size_t> order_data(Proof& pi);

        // A helper class for "ordering" data and for binary search
        struct SortingType {
            Curvepoint pseudonym;
            size_t index;

            bool operator<( const SortingType& rhs ) const
                { return pseudonym < rhs.pseudonym; }
        };
        
        // BINARY SEARCH
        size_t binary_search(const Curvepoint& index) const;

        // VALID VOTE PROOFS
        bool verify_vote_proof(
            const std::vector<Proof>& pi,
            const std::vector<CurveBipoint>& oldVotes,
            const std::vector<CurveBipoint>& newVotes,
            const Curvepoint& shortTermPublicKey
        ) const;
}; 

#endif