package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
    "sync"
)

type Task struct {
    x int
    c chan int
}

type Darbuotojas struct {
    vardas string
    amzius int
    alga float64
}
type rasytojuContainer struct {
    masyvas []Darbuotojas
}

type skaitytojuStruktura struct
{
     elementas int
     kiekis int
}

type skaitytojuContainer struct
{
    masyvas  []skaitytojuStruktura
    count int
}

type valdytojoStruktura struct {
    masyvas  []skaitytojuStruktura
}
//a = append(a[:i], a[i+1:]...)
func (v *valdytojoStruktura) deti(elementas int) {

    count := len(v.masyvas)
    newPosition := count;
    for i := 0; i < count; i++ {
        if elementas >= v.masyvas[i].elementas {
            newPosition = i;
            break;
        }
    }

    if newPosition == count {
        v.masyvas = append(v.masyvas, skaitytojuStruktura{elementas, 1})
    } else
    {
        if (v.masyvas[newPosition].elementas == elementas) {
            v.masyvas[newPosition].kiekis++;
        } else {
            v.masyvas = append(v.masyvas, skaitytojuStruktura{0, 0})
            for i := count; i > newPosition; i-- {
                v.masyvas[i] = v.masyvas[i-1];
            }
            v.masyvas[newPosition].elementas = elementas;
            v.masyvas[newPosition].kiekis = 1;
        }
    }
}

func (v *valdytojoStruktura) trinti(elementas int) (bool) {
    for i := 0; i < len(v.masyvas); i++{
        if v.masyvas[i].elementas == elementas {
            if v.masyvas[i].kiekis > 1 {
                v.masyvas[i].kiekis--;
                return true
            } else {
                v.masyvas = append(v.masyvas[:i], v.masyvas[i+1:]...)
                return true
            }
        }
    }
    return false
}

func readFromFile(fileName string) ([]rasytojuContainer, []skaitytojuContainer, error) {
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Println(err)
        return nil, nil, err
    }
    scanner := bufio.NewScanner(file)

    //Reading data for writer threads
    scanner.Scan()
    var rasytojuDuomenys []rasytojuContainer
    for i := 0; scanner.Text() != "-"; i++ {

        var container rasytojuContainer
        for j := 0; scanner.Text() != ""; j++ {

            var darbuotojas Darbuotojas
            values := strings.Split(scanner.Text(), " ")
            darbuotojas.vardas = values[0]
            amzius, err := strconv.Atoi(values[1])
            if err != nil {
                fmt.Println(err)
                return nil, nil, err
            }
            alga, err := strconv.ParseFloat(values[2], 64)
            if err != nil {
                fmt.Println(err)
                return nil, nil, err
            }
            darbuotojas.amzius = amzius
            darbuotojas.alga = alga

            container.masyvas = append(container.masyvas, darbuotojas)
            scanner.Scan()
        }
        rasytojuDuomenys = append(rasytojuDuomenys, container)
        scanner.Scan()
    }

    //Reading data for reader threads
    var skaitytojuDuomenys []skaitytojuContainer
    scanner.Scan()
    for i := 0; scanner.Text() != "-"; i++ {

        var container skaitytojuContainer
        for j := 0; scanner.Text() != ""; j++ {
            var struktura skaitytojuStruktura
            values := strings.Split(scanner.Text(), " ")
            elementas, err := strconv.Atoi(values[0])
            if err != nil {
                fmt.Println(err)
                return nil, nil, err
            }
            kiekis, err := strconv.Atoi(values[1])
            if err != nil {
                fmt.Println(err)
                return nil, nil, err
            }
            struktura.elementas = elementas
            struktura.kiekis = kiekis

            container.masyvas = append(container.masyvas, struktura)
            scanner.Scan()
        }

        skaitytojuDuomenys = append(skaitytojuDuomenys, container)

        scanner.Scan()
    }
    file.Close()
    return rasytojuDuomenys, skaitytojuDuomenys, err
}

func printToFile(fileName string, rasytojuDuomenys []rasytojuContainer, skaitytojuDuomenys []skaitytojuContainer, valdytojoDuomenys valdytojoStruktura) {
    file, err := os.Create(fileName)
    if err != nil {
        return
    }
    defer file.Close()
    writer := bufio.NewWriter(file)
    fmt.Fprint(writer, "Rasytoju duomenys:\r\n")
    for i := 0 ; i < len(rasytojuDuomenys); i++ {
        fmt.Fprintf(writer, "Rasytojas nr. %d:\r\n", i + 1)
        fmt.Fprint(writer, "----------------------------------------\r\n")
        fmt.Fprintf(writer,"%3s %-15s %4s %10s\r\n", "eil", "Vardas", "Met.", "Alga")
        for j := 0; j < len(rasytojuDuomenys[i].masyvas); j++{
            fmt.Fprintf(writer, "%3d %-15s %4d %10.2f\r\n", j + 1, rasytojuDuomenys[i].masyvas[j].vardas, rasytojuDuomenys[i].masyvas[j].amzius, rasytojuDuomenys[i].masyvas[j].alga)
        }
        fmt.Fprint(writer, "----------------------------------------\r\n")
    }
    fmt.Fprint(writer, "Skaitytoju duomenys:\r\n")
    for i := 0 ; i < len(skaitytojuDuomenys); i++ {
        fmt.Fprintf(writer, "Skaitytojas nr. %d:\r\n", i + 1)
        fmt.Fprint(writer, "----------------------------------------\r\n")
        fmt.Fprintf(writer,"%3s %10s %6s\r\n", "eil", "elementas", "kiekis")
        for j := 0; j < len(skaitytojuDuomenys[i].masyvas); j++{
            fmt.Fprintf(writer, "%3d %10d %6d\r\n", j + 1, skaitytojuDuomenys[i].masyvas[j].elementas, skaitytojuDuomenys[i].masyvas[j].kiekis)
        }
        fmt.Fprint(writer, "----------------------------------------\r\n")
    }
    fmt.Fprint(writer, "Rezultatas:\r\n")
    fmt.Fprint(writer, "----------------------------------------\r\n")
    fmt.Fprintf(writer,"%3s %10s %6s\r\n", "eil", "elementas", "kiekis")
    for i := 0 ; i < len(valdytojoDuomenys.masyvas); i++ {

        fmt.Fprintf(writer, "%3d %10d %6d\r\n", i + 1, valdytojoDuomenys.masyvas[i].elementas, valdytojoDuomenys.masyvas[i].kiekis)
    }
    fmt.Fprint(writer, "----------------------------------------\r\n")
    writer.Flush()
}

func main() {
    rasytojuDuomenys, skaitytojuDuomenys, error := readFromFile("IFF64_PetkusR_L2_1.txt")

    if error != nil {
        fmt.Println("klaida nuskaitant duomenys")
        return
    }
    //fmt.Println(skaitytojuDuomenys)
    //fmt.Println(rasytojuDuomenys)

    var rasytojoDuomenuPerdavimoKanalas = make(chan rasytojuContainer)
    var skaitytojoDuomenuPerdavimoKanalas = make(chan skaitytojuContainer)

    go duomenuPerdavimas(rasytojoDuomenuPerdavimoKanalas, skaitytojoDuomenuPerdavimoKanalas, rasytojuDuomenys, skaitytojuDuomenys)

    var programosBaigimoKanalas = make(chan valdytojoStruktura)
    var rasytojuBaigimoKanalas = make(chan bool)
    var skaitytojuBaigimoKanalas = make(chan bool)

    var rasytojuValdymoKanalas = make(chan int)
    var skaitytojuValdymoKanalas = make(chan Task)

    var rasytojuWaitGroup sync.WaitGroup
    var skaitytojuWaitGroup sync.WaitGroup
    rasytojuWaitGroup.Add(len(rasytojuDuomenys))
    skaitytojuWaitGroup.Add(len(skaitytojuDuomenys))
    //var names = []string {"First", "Second", "Third", "Fourth", "Fifth"}
    //for i := 0; i < 5; i++ {
    //  var message = rand.Intn(65535)
    //  go sender(channel, names[i], message)
    //}
    //go receiver(channel, finishChannel)
    for i := 0; i < len(rasytojuDuomenys); i++ {
        go rasytojoDarbas(rasytojoDuomenuPerdavimoKanalas, rasytojuValdymoKanalas, &rasytojuWaitGroup)
    }
    for i := 0; i < len(skaitytojuDuomenys); i++ {
        go skaitytojoDarbas(skaitytojoDuomenuPerdavimoKanalas, skaitytojuValdymoKanalas, &skaitytojuWaitGroup)
    }
    go valdytojoDarbas(rasytojuValdymoKanalas, skaitytojuValdymoKanalas, rasytojuBaigimoKanalas, skaitytojuBaigimoKanalas, programosBaigimoKanalas)

    go func(){
        rasytojuWaitGroup.Wait();
        rasytojuBaigimoKanalas <- true
    }()
    go func(){
        skaitytojuWaitGroup.Wait();
        skaitytojuBaigimoKanalas <- true
    }()

    galutineStruktura := <-programosBaigimoKanalas
    printToFile("rez.txt", rasytojuDuomenys, skaitytojuDuomenys, galutineStruktura)
}
func duomenuPerdavimas(rasytojuKanalas chan<- rasytojuContainer, skaitytojuKanalas chan<- skaitytojuContainer,
    rasytojuDuomenys []rasytojuContainer, skaitytojuDuomenys []skaitytojuContainer) {
    for _, duomenys := range rasytojuDuomenys {
        rasytojuKanalas <- duomenys
    }
    for _, duomenys := range skaitytojuDuomenys {
        skaitytojuKanalas <- duomenys
    }

}

func valdytojoDarbas(rasytojoKanalas <-chan int, skaitytojoKanalas <-chan Task,
    rasytojuBaigimoKanalas <-chan bool, skaitytojuBaigimoKanalas <-chan bool, programosBaigimoKanalas chan<- valdytojoStruktura) {

    var galutinisKonteineris valdytojoStruktura
    skaitytojaiBaige := false
    rasytojaiBaige := false
    for ; !skaitytojaiBaige || !rasytojaiBaige; {
        select {
        case rasytojoDuomenys := <-rasytojoKanalas:
            //fmt.Println("Dedu: ", rasytojoDuomenys)
            galutinisKonteineris.deti(rasytojoDuomenys)
        case skaitytojoDuomenys := <-skaitytojoKanalas:
            //fmt.Println("Trinu: ", skaitytojoDuomenys)
            if galutinisKonteineris.trinti(skaitytojoDuomenys.x) || rasytojaiBaige{
                //fmt.Println("Pavyko")
                skaitytojoDuomenys.c <- 1
            } else {
                //fmt.Println("nePavyko")
                skaitytojoDuomenys.c <- 0
            }
        case rasytojaiBaige = <-rasytojuBaigimoKanalas:

        case skaitytojaiBaige = <-skaitytojuBaigimoKanalas:
        }
    }
    programosBaigimoKanalas <- galutinisKonteineris
}

func rasytojoDarbas(duomenuGavimoKanalas <-chan rasytojuContainer, duomenuSiuntimoKanalas chan<- int, waitGroup *sync.WaitGroup){
    defer waitGroup.Done()

    duomenys := <- duomenuGavimoKanalas
    for i := 0; i < len(duomenys.masyvas); i++{
        duomenuSiuntimoKanalas <- duomenys.masyvas[i].amzius;
    }
    //fmt.Println("Rasytojo duomenys", duomenys)
}

func skaitytojoDarbas(duomenuGavimoKanalas <-chan skaitytojuContainer, duomenuSiuntimoKanalas chan<- Task, waitGroup *sync.WaitGroup) {
    defer waitGroup.Done()
    duomenys := <-duomenuGavimoKanalas
    baigtuTrintiSkaicius := 0
    for ;baigtuTrintiSkaicius < len(duomenys.masyvas); {
        for i := 0; i < len(duomenys.masyvas); i++ {
            naujasKiekis := duomenys.masyvas[i].kiekis
            for j := 0; j < duomenys.masyvas[i].kiekis; j++ {
                grazinimoKanalas := make(chan int)
                //fmt.Println("Trinu: ", duomenys.masyvas[i].elementas)
                duomenuSiuntimoKanalas <- Task{duomenys.masyvas[i].elementas, grazinimoKanalas};
                success := <-grazinimoKanalas
                if success == 1 {
                    //fmt.Println("Istryniau", duomenys.masyvas[i].elementas)
                    naujasKiekis--
                } else {

                }
            }
            if naujasKiekis == 0 && duomenys.masyvas[i].kiekis != 0 {
                baigtuTrintiSkaicius++
            }
            duomenys.masyvas[i].kiekis = naujasKiekis
            //fmt.Println("Skaitytojo duomenys", duomenys)
        }
    }
}
//func sender(channel chan<- int, name string, x int) {
//  fmt.Println(name, "is going to send value", x)
//  channel <- x
//}
//func receiver(channel <-chan int, finishChannel chan<- bool) {
//  var a int
//  for i := 0; i < 5; i++ {
//      a = <- channel
//      fmt.Println("Received value", a)
//  }
//  finishChannel <- true
//}