package main

import (
        "database/sql"
        "flag"
        "fmt"
        "log"
        "sync"
        "time"

        _ "github.com/go-sql-driver/mysql"
)

type datarow struct {
        pk1       int
        pk2       int
        pk3       int
        pk4       int
        startTime time.Time
        endTime   time.Time
}

var MAX_CONCURRENT = 150

func main() {
        user := flag.String("user", "root", "db user name")
        pass := flag.String("pass", "root", "db password")
        host := flag.String("host", "127.0.0.1", "db host")
        port := flag.Int("port", 3306, "port")
        flag.Parse()

        db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:%d)/?charset=utf8", *user, *pass, *host, *port))
        if err != nil {
                log.Fatal(err)
        }
        defer db.Close()
        db.SetMaxOpenConns(10)

        _, err = db.Exec("CREATE DATABASE IF NOT EXISTS test")
        if err != nil {
                log.Fatal(err)
        }

        _, err = db.Exec("DROP TABLE IF EXISTS test.t1")
        if err != nil {
                log.Fatal(err)
        }

        create := `
        CREATE TABLE test.t1 (
                      pk1 int(11) NOT NULL,
                      pk2 int(11) NOT NULL,
                      pk3 int(11) NOT NULL,
                      pk4 int(11) NOT NULL,
                      f1 timestamp NULL DEFAULT NULL,
                      f2 timestamp NULL DEFAULT NULL,
                      PRIMARY KEY (pk1,pk2,pk3,pk4)
                    ) ENGINE=InnoDB DEFAULT CHARSET=utf8`
        _, err = db.Exec(create)
        if err != nil {
                log.Fatal(err)
        }

        ps, err := db.Prepare("INSERT INTO test.t1 VALUES (?,?,?,?,?,?)")
        if err != nil {
                log.Fatal(err)
        }
        defer ps.Close()

        ch := make(chan datarow, MAX_CONCURRENT*2)
        var wg sync.WaitGroup
        for i := 0; i < MAX_CONCURRENT; i++ {
                wg.Add(1)
                go write(ps, ch, &wg)
        }

        count := 0
        for pk1 := 0; pk1 < 100; pk1++ {
                for pk2 := 0; pk2 < 100; pk2++ {
                        for pk3 := 0; pk3 < 100; pk3++ {
                                for pk4 := 0; pk4 < 10; pk4++ {
                                        rs := datarow{
                                                pk1:       pk1,
                                                pk2:       pk2,
                                                pk3:       pk3,
                                                pk4:       pk4,
                                                startTime: time.Now().UTC(),
                                                endTime:   time.Now().UTC(),
                                        }
                                        ch <- rs
                                        count++
                                }
                        }
                        fmt.Println(count)
                }
                fmt.Println(count)
        }
        fmt.Println(count)
        close(ch)
        wg.Wait()

}

func write(ps *sql.Stmt, c chan datarow, wg *sync.WaitGroup) {
        for rs := range c {
                _, err := ps.Exec(rs.pk1, rs.pk2, rs.pk3, rs.pk4, rs.startTime, nil)
                if err != nil {
                        log.Println(err)
                }
        }
        wg.Done()
}