package main

import (
    "os"
    "fmt"
    "strconv"
    "math/rand"
    "math"
    "flag"
    "time"
)




//var percent = 0.00000011946
var pi = math.Pi;// float64(3.1415926535897932384626433832795)
var coef10 = float64(10)/math.Log(10)
var year = 365.25
var year_blocks = int(30*24*year)
var percent_year = math.Pi / 100 + 1.0;
var percent_day_multi = math.Pow(1+percent_year, float64(1.0/year))
var percent_block = (percent_day_multi - 1) / 720.0
var second_in_block = 2 * 60

var powp4 = 20.0
var powp3 = 0.0
// *= 1 + pow4 / (X + pow3) - year pow multi
var powp0 = 12
var powp1 = .75
var powp2 = .05
// year 0: +- 75% delta, year 1: +- 70% delta, ..., year pow0: +-15% delta, ..., year pow0+: +-(pow1 - pow0*pow2)*100% delta

var start_pow_power = float64(10.0)
var ideal_pow_power = start_pow_power;
var default_pos_power = float64(1.0)
var max_target = uint64(0x00ffffffffffffff)
var pow_target = max_target
var pos_target = max_target

var Coin = uint64(1000000)
var Cent = uint64(10000)

var mplus, wMplus, sMplus float64

var wDiff = float64(1.0)
var sDiff = 0.0001

var supply = 0.0//moneysupply
var M = uint64(supply)

var second [5040]uint64
var is_pos [5040]bool
var array_index = uint(0);
var prev_index = uint(0);
var Qpos = 0;
var p_pos = 0.25;

func main() {
    flag.Parse()
    fl, _ := strconv.ParseInt(flag.Arg(0), 10, 8)
    eot := year_blocks * int(fl) + 1
    wReward := 0.0
    sReward := 0.0
    mwReward := 0.0;
    msReward := 0.0
    ywReward := 0.0;
    ysReward := 0.0
    for i:= 0; i<5040; i++{
        second[i]=0;
        is_pos[i]=false;
    }
    second[0]=1;
    fmt.Println("PoS: Fees=", eot)
    //years to mine in blocks
    //    fmt.Println(eot)
    //    os.Exit(0)
    rnd := rand.New(rand.NewSource(int64(time.Now().Nanosecond())))
    current_pow_power := ideal_pow_power;
    for block := 0; block < eot; block++ {
//  for block := 0; block < 9600; block++ {
        if (block % (720 * 30)) == 0{
            month := block / (720*30) + 1;
            multi_pow := math.Exp(math.Log(1 + 12 * powp4 / float64(month)) / 12)
            ideal_pow_power = ideal_pow_power * multi_pow;
            if (block % 720) == 0{
                delta_y := block / year_blocks;
                if delta_y > powp0 {delta_y = powp0}
                current_pow_power = (1.0 - ((powp1 - float64(delta_y) * powp2) * (1 - 2 * rnd.Float64()))) * ideal_pow_power;
            }
        }
        prev_index = array_index;
        array_index++;
        if array_index == 5040 {array_index = 0}
        delta_time := second[prev_index] - second[array_index];

        multi_pow_target := float64(1.0);
        if block < 5040 {
            if block > 0{
                multi_pow_target *= float64(delta_time) / float64(second_in_block * block)
            }
        }else{
            multi_pow_target *= float64(delta_time) / float64(second_in_block * 5040)
        }
        global_system_time := second[prev_index];
        if block > 5040{
            multi_pow_target *= float64(global_system_time) / float64(block * second_in_block)
        }
        if (multi_pow_target > 1.01) {multi_pow_target = 1.01}
        if (multi_pow_target < 0.99) {multi_pow_target = .99}
        pow_target = uint64(float64(pow_target) * multi_pow_target)
        if pow_target > max_target {pow_target = max_target}

        if Qpos == 0{
            pos_target = max_target;
        }else{
            pos_target = uint64(float64(pos_target) * p_pos * float64(5040) / (float64(Qpos))) + 1
        }

        p0 := 1.0 / float64(second_in_block);
        p0 *= current_pow_power / start_pow_power;
        p0 *= float64(pow_target)/float64(max_target);

        if (p0 >=1) {p0 = .9999999};
        // S(n) = 1 - q^n
        time_to_pow := uint64(math.Log(.005 + .99 * rnd.Float64()) / math.Log(1 - p0));

        p0 = float64(max_target)/float64(pow_target) / (current_pow_power/start_pow_power)

        pos_coin := (float64(M)/float64(Coin)) * 0.5;
        // 60 - dney v srednev, p_pos - %pos blokov; razmazyvaem monety po blokam.
        pos_coin *= p_pos / (60 * 720)
        pos_time := 30 + 60 * rnd.Float64();
        if (block < 30 * 720) {
            pos_time = 0
        }else if block < 90 * 720{
            pos_time = 30 + float64(block/720 - 30) * rnd.Float64();
        }

        coin_age := pos_coin * pos_time / year;
        p1 := 1.0 / float64(second_in_block);
        p1 *= default_pos_power / start_pow_power;
        p1 *= float64(pos_target)*coin_age/float64(max_target);
        if (p1 >= 1) {p1 = .9999999}
        time_to_pos := uint64(math.Log(.005 + .99 * rnd.Float64()) / math.Log(1 - p1));

        if time_to_pow < time_to_pos{
            reward_ln := 10 + coef10 * math.Log(float64(max_target)/float64(pow_target));
            reward_percent := float64(M) * percent_block / float64(Coin);
            wReward = reward_ln + reward_percent;
            if is_pos[array_index] {Qpos--; is_pos[array_index] = false;}
            second[array_index] = second[prev_index] + time_to_pow;
            M += uint64(float64(Coin)*wReward);
            mwReward += wReward
            ywReward += wReward
//          fmt.Println("PoW: ", wReward)
        }else{
            sReward = coin_age * 0.01
            if !is_pos[array_index] {Qpos++; is_pos[array_index] = true;}
            second[array_index] = second[prev_index] + time_to_pos;
            M += uint64(float64(Coin)*sReward);
//          fmt.Println("PoS: ", sReward, "time = ", time_to_pos, "ind", array_index)
            msReward += sReward;
            ysReward += sReward
        }

        if (1 * block % year_blocks) == 0 {
            fmt.Println("money =", M / Coin, ",", M % Coin, "\t year#", block / year_blocks)
            fmt.Println("month pos:", msReward, " year pos:", ysReward, "month pow:", mwReward, " year pow:", ywReward)
            fmt.Println("current_pow: ", current_pow_power, " delta time:", delta_time, " real time:", block*second_in_block, " system time:", global_system_time)
            fmt.Println("target pos=", pos_target, " pow=", pow_target, " max=",max_target, " mat o;idanie:", p0)
            fmt.Println("==========================================================")
        }
        if (block % year_blocks) == 0{
            ywReward = 0
            ysReward = 0
        }
        if (12 * block % year_blocks) == 0{
            mwReward = 0
            msReward = 0
        }
    }

    os.Exit(0)
}