// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include "assert.h"

#include "chainparams.h"
#include "main.h"
#include "util.h"

#include <boost/assign/list_of.hpp>

using namespace boost::assign;

struct SeedSpec6 {
    uint8_t addr[16];
    uint16_t port;
};

#include "chainparamsseeds.h"

//
// Main network
//

// Convert the pnSeeds6 array into usable address objects.
static void convertSeed6(std::vector<CAddress> &vSeedsOut, const SeedSpec6 *data, unsigned int count)
{
    // It'll only connect to one or two seed nodes because once it connects,
    // it'll get a pile of addresses with newer timestamps.
    // Seed nodes are given a random 'last seen time' of between one and two
    // weeks ago.
    const int64_t nOneWeek = 7*24*60*60;
    for (unsigned int i = 0; i < count; i++)
    {
        struct in6_addr ip;
        memcpy(&ip, data[i].addr, sizeof(ip));
        CAddress addr(CService(ip, data[i].port));
        addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek;
        vSeedsOut.push_back(addr);
    }
}

class CMainParams : public CChainParams {
public:
    CMainParams() {
        // The message start string is designed to be unlikely to occur in normal data.
        // The characters are rarely used upper ASCII, not valid as UTF-8, and produce
        // a large 4-byte int at any alignment.
        pchMessageStart[0] = 0xdb;
        pchMessageStart[1] = 0xad;
        pchMessageStart[2] = 0xbd;
        pchMessageStart[3] = 0xda;
        vAlertPubKey = ParseHex("0486bce1bac0d543f104cbff2bd23680056a3b9ea05e1137d2ff90eeb5e08472eb500322593a2cb06fbf8297d7beb6cd30cb90f98153b5b7cce1493749e41e0284");
        nDefaultPort = 10592;
        nRPCPort = 10593;
        bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20);
        
			// 05/21/15 15:53:43 Loading block index...
			// 05/21/15 15:53:43 CBlock(hash=00000bbaf441790c5e20c59fd20a0379795fe4e7e33c5a0c483a72d6c9055aaa, 
			//							ver=1, 
			//							hashPrevBlock=0000000000000000000000000000000000000000000000000000000000000000, 
			//							hashMerkleRoot=4b111555e2e3d9dcf555cdffc2f078a005aab270e9e5d238c586795d707dacb4, 
			//							nTime=1431008360, 
			//							nBits=1e0fffff, 
			//							nNonce=320411, 
			//							vtx=1, 
			//							vchBlockSig=)
			
			// 05/21/15 15:53:43   Coinbase(hash=4b111555e2, nTime=1431008360, ver=1, vin.size=1, vout.size=1, nLockTime=0)
			//    CTxIn(COutPoint(0000000000, 4294967295), 
			//	coinbase 04ffff001d020f274c526867353472683337387774667233346879646533346872663930387233346833353479667767376
			//			 6333474373837333435777439373335366874666779353777746775383972797439383777333474677933)
			//    CTxOut(empty)
			//  vMerkleTree: 4b111555e2 
			
			// 05/21/15 15:53:43 block.GetHash() == 00000bbaf441790c5e20c59fd20a0379795fe4e7e33c5a0c483a72d6c9055aaa
			// 05/21/15 15:53:43 block.hashMerkleRoot == 4b111555e2e3d9dcf555cdffc2f078a005aab270e9e5d238c586795d707dacb4
			// 05/21/15 15:53:43 block.nTime = 1431008360 
			// 05/21/15 15:53:43 block.nNonce = 320411 

        // Build the genesis block. Note that the output of the genesis coinbase cannot
        // be spent as it did not originally exist in the database.				
        const char* pszTimestamp = "hg54rh378wtfr34hyde34hrf908r34h354yfwg7f34t787345wt97356htfgy57wtgu89ryt987w34tgy3";
        CTransaction txNew;
		txNew.nTime = 1431008360;
        txNew.vin.resize(1);
        txNew.vout.resize(1);
        txNew.vin[0].scriptSig = CScript() << 0 << CBigNum(42) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
        txNew.vout[0].nValue = 7000 * COIN;
        txNew.vout[0].scriptPubKey = CScript() << ParseHex("0236d7e14ffeeff8d420f8d48a2ccd72d7178f0b1b01f926f4d6565a97a124772b") << OP_CHECKSIG;
        genesis.vtx.push_back(txNew);
        genesis.hashPrevBlock = 0;
        genesis.hashMerkleRoot = genesis.BuildMerkleTree();
        genesis.nVersion = 1;
        genesis.nTime    = 1431008360;
        genesis.nBits    = 0x1e0fffff;
        genesis.nNonce   = 320411;

        hashGenesisBlock = genesis.GetPoWHash();
		//LogPrintf("hashGenesisBlock = %s\n", genesis.GetPoWHash().ToString());		
        assert(hashGenesisBlock == uint256("00000bbaf441790c5e20c59fd20a0379795fe4e7e33c5a0c483a72d6c9055aaa"));
		//LogPrintf("hashMerkleRoot = %s\n", genesis.BuildMerkleTree().ToString());
        assert(genesis.hashMerkleRoot == uint256("4b111555e2e3d9dcf555cdffc2f078a005aab270e9e5d238c586795d707dacb4"));
       
        base58Prefixes[PUBKEY_ADDRESS] = list_of(75);
        base58Prefixes[SCRIPT_ADDRESS] = list_of(9);
        base58Prefixes[SECRET_KEY] =     list_of(153);
        base58Prefixes[EXT_PUBLIC_KEY] = list_of(0x14)(0x44)(0xC1)(0xA7);
        base58Prefixes[EXT_SECRET_KEY] = list_of(0x44)(0xC8)(0xD1)(0xFF);

        convertSeed6(vFixedSeeds, pnSeed6_main, ARRAYLEN(pnSeed6_main));

        nLastPOWBlock = 2500;
    }

    virtual const CBlock& GenesisBlock() const { return genesis; }
    virtual Network NetworkID() const { return CChainParams::MAIN; }

    virtual const vector<CAddress>& FixedSeeds() const {
        return vFixedSeeds;
    }
protected:
    CBlock genesis;
    vector<CAddress> vFixedSeeds;
};
static CMainParams mainParams;


//
// Testnet
//

class CTestNetParams : public CMainParams {
public:
    CTestNetParams() {
        // The message start string is designed to be unlikely to occur in normal data.
        // The characters are rarely used upper ASCII, not valid as UTF-8, and produce
        // a large 4-byte int at any alignment.
        pchMessageStart[0] = 0xdd;
        pchMessageStart[1] = 0x4d;
        pchMessageStart[2] = 0xdd;
        pchMessageStart[3] = 0x4d;
        bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20);
        vAlertPubKey = ParseHex("04ecb36d13861c56f7ad14529bc54dc0b5d5d954586698c2fc244045c617e44ed07994808643f67a71e3c1003e8506fef238cfb98bf9468c1f7b9a684c5b536f55");
        nDefaultPort = 78158;
        nRPCPort = 76158;
        strDataDir = "testnet";

        // Modify the testnet genesis block so the timestamp is valid for a later start.
        genesis.nTime = 1431008260;
        genesis.nNonce = 956496;
        genesis.nBits  = 0x1e0ffff0;
        
        hashGenesisBlock = genesis.GetPoWHash();  
        
		//LogPrintf("hashGenesisTESTNETBlock = %s\n", genesis.GetPoWHash().ToString());
        assert(hashGenesisBlock == uint256("0x"));

        vFixedSeeds.clear();
        vSeeds.clear();

        base58Prefixes[PUBKEY_ADDRESS] = list_of(1);
        base58Prefixes[SCRIPT_ADDRESS] = list_of(199);
        base58Prefixes[SECRET_KEY]     = list_of(421);
        base58Prefixes[EXT_PUBLIC_KEY] = list_of(0x00)(0x01)(0xA3)(0xFF);
        base58Prefixes[EXT_SECRET_KEY] = list_of(0xC2)(0xA3)(0x00)(0x99);

        convertSeed6(vFixedSeeds, pnSeed6_test, ARRAYLEN(pnSeed6_test));

        nLastPOWBlock = 0x7fffffff;
    }
    virtual Network NetworkID() const { return CChainParams::TESTNET; }
};
static CTestNetParams testNetParams;


static CChainParams *pCurrentParams = &mainParams;

const CChainParams &Params() {
    return *pCurrentParams;
}

void SelectParams(CChainParams::Network network) {
    switch (network) {
        case CChainParams::MAIN:
            pCurrentParams = &mainParams;
            break;
        case CChainParams::TESTNET:
            pCurrentParams = &testNetParams;
            break;
        default:
            assert(false && "Unimplemented network");
            return;
    }
}

bool SelectParamsFromCommandLine() {
    
    bool fTestNet = GetBoolArg("-testnet", false);
    
    if (fTestNet) {
        SelectParams(CChainParams::TESTNET);
    } else {
        SelectParams(CChainParams::MAIN);
    }
    return true;
}