import math
import time
import fileinput
import os
import timeit
import platform
import sys
try:
    from time import monotonic as timeout_time
except ImportError:
    timeout_time = time.time

def compute_precision(func):
    precision = None
    points = 0
    timeout = timeout_time() + 1.0
    previous = func()
    while timeout_time() < timeout or points < 3:
        for loop in range(10):
            t1 = func()
            t2 = func()
            dt = t2 - t1
            if 0 < dt:
                break
        else:
            dt = t2 - previous
            if dt <= 0.0:
                continue
        if precision is not None:
            precision = min(precision, dt)
        else:
            precision = dt
        points += 1
        previous = func()
    return precision

def largeWork():

    for x in range(1,20000):
        u"Testing Format %s".format(u"AAAAA" * 20000)



class Benchmark:
    def __init__(self, timer=None):
        if timer is None:
            timer = time.time
        self.timer = timer
        self.timer_precision = None
        self.time_unit = ("ns", 1e-9)
        self.min_time = 0.1
        self.max_time = 1.0
        self.min_repeat = 5
        #self.max_repeat = 1000
        self.max_repeat = None

    def format_delta(self, dt):
        if dt >= 1.0:
            return "%.3g sec" % (dt,)
        elif dt >= 1e-3:
            return "%.3g ms" % (dt * 1e3,)
        elif dt >= 1e-6:
            return "%.3g ms" % (dt * 1e6,)
        else:
            return "%.0f ns" % (dt * 1e9,)

    def run(self, stmt="pass", setup="pass", msg=None):
        if msg is None:
            if setup != "pass":
                msg = "%s; %s" % (setup, stmt)
            else:
                msg = stmt
        timer = timeit.Timer(stmt=stmt, setup=setup, timer=self.timer)

        # Calibrate the number of loops
        if self.min_time < 1.0:
            if self.timer_precision is None:
                self.timer_precision = compute_precision(self.timer)
                print("Clock precision = %s" % self.format_delta(self.timer_precision))
            min_time = max(self.min_time, self.timer_precision * 100)
            min_time_estimate = max(self.min_time / 100, self.timer_precision * 10)
        else:
            min_time = self.min_time
            min_time_estimate = self.min_time / 100

        loops = 1
        estimate = False
        min_progress = 1.0
        while True:
            dt = timer.timeit(number=loops)
            best = dt / loops

            if dt / min_time >= min_progress:
                break

            # coarse estimation of the number of loops
            if not estimate and dt >= min_time_estimate:
                estimate = True
                old = loops
                loops = max(int(min_time / best), loops * 2)
                min_progress = 0.75
            else:
                loops *= 10

        # Choose how many time we must repeat the test
        repeat = int(math.ceil(self.max_time / dt))
        if self.max_repeat is not None:
            repeat = min(repeat, self.max_repeat)
        repeat = max(repeat, self.min_repeat)
        if 1 < repeat:
            # Repeat the benchmark
            best_repeat = min(timer.repeat(repeat=(repeat - 1), number=loops))
            best = min(best, best_repeat / loops)
        best = self.format_delta(best)
        print("% 5s: %s" % (best, msg))







def main():
    print(sys.version.splitlines()[0])
    print(platform.platform())
    bench = Benchmark()

    u"Prep %s".format("Hi")
    u"Prep %s".format()

    bench.run(setup="from __main__ import largeWork",stmt='largeWork()')

    print("My PID %d " % os.getpid())
    print("Done... Please measure profile")
    for line in fileinput.input():
        pass



if __name__ == "__main__":
    main()