package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
    "sync"
)

type Items struct {
    Items []Item `json:"cars"`
}

type Item struct {
    Name string `json:"name"`
    Year float64 `json:"year"`
    Mileage float64 `json:"mileage"`
}

type ItemsResult struct {
    ItemsResult [20]ItemResult `json:"items"`
    Count int
}

type ItemResult struct {
    Item Item
    AnnualMileage float64
}

type ItemsMonitor struct {
    Items [10]Item
    Count int
    Mutex sync.Mutex
    MutexForCount sync.Mutex
}

func (monitor *ItemsMonitor) addItem(item Item){
    if monitor.Count == 0 {
        monitor.MutexForCount.Unlock()
    }
    monitor.MutexForCount.Lock()
    monitor.Items[monitor.Count] = item
    monitor.Count++
    if monitor.Count < 10 {
        monitor.MutexForCount.Unlock()
    }
}

func (monitor *ItemsMonitor) removeItem(itemsResult *ItemsResult, i int){
    if monitor.Count < 10 {
        monitor.MutexForCount.Lock()
    }
    var item Item
    if monitor.Count != 0 {
        monitor.Items[monitor.Count - 1] = item
        monitor.Count--
    }
    if monitor.Count < 10 {
        monitor.MutexForCount.Unlock()
    }
    if monitor.Count == 0 {
        monitor.MutexForCount.Lock()
    }
}

func (monitor *ItemsMonitor) calculateAndSort(value bool, i int, itemsMonitor *ItemsMonitor, items *Items, itemsResult *ItemsResult) {
    var index int
    for value == false {
        if(itemsResult.ItemsResult[index].Item.Year == 0){
            i = index
            value = true
        }
        index++
    }
    monitor.Mutex.Lock()
    defer monitor.Mutex.Unlock()
    if itemsMonitor.Items[itemsMonitor.Count - 1].Year >= 15 {
        var itemResult ItemResult
        itemResult.Item = itemsMonitor.Items[itemsMonitor.Count - 1]
        itemResult.AnnualMileage = itemsMonitor.Items[itemsMonitor.Count - 1].Mileage  / itemsMonitor.Items[itemsMonitor.Count - 1].Year

        less := false
        if i == 0 {
            itemsResult.ItemsResult[i] = itemResult
        }
        var itemToMove ItemResult
        var copyOfItem ItemResult
        for j := 1; j <= i ; j++  {
            if less == true  {
                copyOfItem = itemToMove
                itemToMove = itemsResult.ItemsResult[j]
                itemsResult.ItemsResult[j] = copyOfItem
            } else {
                if j - 1 >= 0 && j <= len(items.Items) && itemsResult.ItemsResult[j - 1].AnnualMileage > itemResult.AnnualMileage && itemResult.AnnualMileage < itemsResult.ItemsResult[j].AnnualMileage {
                    itemToMove = itemsResult.ItemsResult[j]
                    itemsResult.ItemsResult[j] = itemsResult.ItemsResult[j - 1]
                    itemsResult.ItemsResult[j - 1] = itemResult

                    less = true
                }
                if j - 1 >= 0 && j + 1 <= 19 && j <= len(items.Items) && itemsResult.ItemsResult[j - 1].AnnualMileage > itemResult.AnnualMileage && 0 == itemsResult.ItemsResult[j].AnnualMileage {
                    itemsResult.ItemsResult[j] = itemsResult.ItemsResult[j - 1]
                    itemsResult.ItemsResult[j - 1] = itemResult
                    less = true
                } else if j == i {
                    itemsResult.ItemsResult[j] = itemResult
                }
            }
        }
        itemsResult.Count++
    }
}

func check(e error) {
    if e != nil {
        panic(e)
    }
}

func writeToResultFile(itemsResult ItemsResult)  {
    f, err := os.Create("result.txt")
    check(err)
    defer f.Close()
    f.WriteString(fmt.Sprintf("%20s%20s%20s%30s \n", "Pavadinimas", "Metai", "Rida", "Vid. Km per metus"))
    f.WriteString("------------------------------------------------------------------------------------------- \n")
    for i := 0; i < itemsResult.Count; i++ {
        test := fmt.Sprintf("%20s%20f%20f%30f \n", itemsResult.ItemsResult[i].Item.Name, itemsResult.ItemsResult[i].Item.Year, itemsResult.ItemsResult[i].Item.Mileage, itemsResult.ItemsResult[i].AnnualMileage)
        f.WriteString(test)
    }
}

func main() {
    jsonFile1, err := os.Open("IFF-74_TomkeviciusZ_L1_dat_2.json")
    if err != nil {
        fmt.Println(err)
    }
    defer jsonFile1.Close()
    byteValue, _ := ioutil.ReadAll(jsonFile1)
    var items Items
    _ = json.Unmarshal(byteValue, &items)

    var itemsMonitor ItemsMonitor
    var itemsResult ItemsResult
    var wg sync.WaitGroup
    wg.Add(4)
    itemsMonitor.MutexForCount.Lock()
    go func() {
        for i := 0; i < 5; i++ {
            itemsMonitor.addItem(items.Items[i])
            itemsMonitor.calculateAndSort(false, 1, &itemsMonitor, &items, &itemsResult)
            itemsMonitor.removeItem(&itemsResult, i)
        }
        wg.Done()
    }()
    go func() {
        for i := 5; i < 10; i++ {
            itemsMonitor.addItem(items.Items[i])
            itemsMonitor.calculateAndSort(false, 1, &itemsMonitor, &items, &itemsResult)
            itemsMonitor.removeItem(&itemsResult, i)
        }
        wg.Done()
    }()
    go func() {
        for i := 10; i < 15; i++ {
            itemsMonitor.addItem(items.Items[i])
            itemsMonitor.calculateAndSort(false, 1, &itemsMonitor, &items, &itemsResult)
            itemsMonitor.removeItem(&itemsResult, i)
        }
        wg.Done()

    }()
    go func() {
        for i := 15; i < 20; i++ {
            itemsMonitor.addItem(items.Items[i])
            itemsMonitor.calculateAndSort(false, 1, &itemsMonitor, &items, &itemsResult)
            itemsMonitor.removeItem(&itemsResult, i)
        }
        wg.Done()
    }()
    wg.Wait()

    writeToResultFile(itemsResult)
}