package main

import (
    "fmt"
    "github.com/jbuchbinder/gopnm"
    "image"
    "image/color"
    "log"
    "os"
    "sync"
    "time"
)

var wg sync.WaitGroup

func main() {
    file, err := os.Open("in.pgm")
    if err != nil {
        log.Fatal(err)
    }

    img, format, err := image.Decode(file)

    fmt.Println("Format: ", format)

    if err != nil {
        log.Fatal(err)
    }

    outFile, err := os.Create("out.pgm")
    if err != nil {
        log.Fatal(err)
    }

    start := time.Now()
    //sec(img)
    newImage := sec(&img)
    elapsed := time.Since(start)

    log.Println("Time: ", elapsed)

    err = pnm.Encode(outFile, newImage, pnm.PGM)
    if err != nil {
        log.Fatal(err)
    }

    start = time.Now()
    //sec(img)
    newImage = async(img)
    elapsed = time.Since(start)
    log.Println("Time: ", elapsed)

    outFile, err = os.Create("out2.pgm")
    if err != nil {
        log.Fatal(err)
    }

    err = pnm.Encode(outFile, newImage, pnm.PGM)
    if err != nil {
        log.Fatal(err)
    }
}

func sec(oldImage *image.Image) image.Image {
    newImage := image.NewGray(image.Rectangle{Max: image.Point{X: 1024, Y: 1024}})

    for i := 1; i < 1022; i++ {
        for j := 1; j < 1022; j++ {
            value, _, _, _ := (*oldImage).At(i, j).RGBA()
            up, _, _, _ := (*oldImage).At(i, j-1).RGBA()
            down, _, _, _ := (*oldImage).At(i, j+1).RGBA()
            left, _, _, _ := (*oldImage).At(i-1, j).RGBA()
            right, _, _, _ := (*oldImage).At(i+1, j).RGBA()

            value = ((value * 6) / 10) + ((up) / 10) + ((right) / 10) + ((left) / 10) + ((down) / 10)

            newImage.SetGray(i, j, color.Gray{Y: (uint8)(value >> 8)})
        }
    }

    for i := 1; i < 1022; i++ {
        value, _, _, _ := (*oldImage).At(i, 0).RGBA()
        left, _, _, _ := (*oldImage).At(i-1, 0).RGBA()
        right, _, _, _ := (*oldImage).At(i+1, 0).RGBA()
        down, _, _, _ := (*oldImage).At(i, 1).RGBA()

        value = ((value * 6) / 10) + ((right) / 10) + ((left) / 10) + ((down) / 10)

        newImage.SetGray(i, 0, color.Gray{Y: (uint8)(value >> 8)})
    }

    for i := 1; i < 1022; i++ {
        value, _, _, _ := (*oldImage).At(i, 1023).RGBA()
        left, _, _, _ := (*oldImage).At(i-1, 1023).RGBA()
        right, _, _, _ := (*oldImage).At(i+1, 1023).RGBA()
        up, _, _, _ := (*oldImage).At(i, 1022).RGBA()

        value = ((value * 6) / 10) + ((right) / 10) + ((left) / 10) + ((up) / 10)

        newImage.SetGray(i, 1023, color.Gray{Y: (uint8)(value >> 8)})
    }

    for i := 1; i < 1022; i++ {
        value, _, _, _ := (*oldImage).At(0, i).RGBA()
        up, _, _, _ := (*oldImage).At(0, i-1).RGBA()
        down, _, _, _ := (*oldImage).At(0, i+1).RGBA()
        right, _, _, _ := (*oldImage).At(1, i).RGBA()

        value = ((value * 6) / 10) + ((right) / 10) + ((up) / 10) + ((down) / 10)

        newImage.SetGray(0, i, color.Gray{Y: (uint8)(value >> 8)})
    }

    for i := 1; i < 1022; i++ {
        value, _, _, _ := (*oldImage).At(1023, i).RGBA()
        left, _, _, _ := (*oldImage).At(1022, i).RGBA()
        up, _, _, _ := (*oldImage).At(1023, i+1).RGBA()
        down, _, _, _ := (*oldImage).At(1023, i-1).RGBA()

        value = ((value * 6) / 10) + ((up) / 10) + ((left) / 10) + ((down) / 10)

        newImage.SetGray(0, i, color.Gray{Y: (uint8)(value >> 8)})
    }

    {
        value, _, _, _ := (*oldImage).At(0, 0).RGBA()
        down, _, _, _ := (*oldImage).At(0, 1).RGBA()
        right, _, _, _ := (*oldImage).At(0+1, 0).RGBA()

        value = ((value * 6) / 10) + ((right) / 10) + ((down) / 10)

        newImage.SetGray(0, 0, color.Gray{Y: (uint8)(value >> 8)})
    }

    {
        value, _, _, _ := (*oldImage).At(1023, 0).RGBA()
        down, _, _, _ := (*oldImage).At(1023, 1).RGBA()
        left, _, _, _ := (*oldImage).At(1022, 0).RGBA()

        value = ((value * 6) / 10) + ((left) / 10) + ((down) / 10)

        newImage.SetGray(1023, 0, color.Gray{Y: (uint8)(value >> 8)})
    }

    {
        value, _, _, _ := (*oldImage).At(1023, 1023).RGBA()
        up, _, _, _ := (*oldImage).At(1023, 1022).RGBA()
        left, _, _, _ := (*oldImage).At(1022, 1023).RGBA()

        value = ((value * 6) / 10) + ((up) / 10) + ((left) / 10)

        newImage.SetGray(1023, 1023, color.Gray{Y: (uint8)(value >> 8)})
    }

    {
        value, _, _, _ := (*oldImage).At(0, 1023).RGBA()
        up, _, _, _ := (*oldImage).At(0, 1022).RGBA()
        right, _, _, _ := (*oldImage).At(1, 1023).RGBA()

        value = ((value * 6) / 10) + ((up) / 10) + ((right) / 10)

        newImage.SetGray(0, 1023, color.Gray{Y: (uint8)(value >> 8)})
    }

    return newImage
}

func async(oldImage image.Image) image.Image {
    newImage := image.NewGray(image.Rectangle{Max: image.Point{X: 1024, Y: 1024}})

    wg.Add(5)

    go asyncThread(&oldImage, newImage, 256, 0)
    go asyncThread(&oldImage, newImage, 256, 256)
    go asyncThread(&oldImage, newImage, 256, 512)
    go asyncThread(&oldImage, newImage, 256, 768)
    go asyncThread(&oldImage, newImage, 256, 1024)

    wg.Wait()

    //time.Sleep(time.Second * 10)
    return newImage
}

func asyncThread(oldImage *image.Image, newImage *image.Gray, lines int, start int) {

    defer wg.Done()
    for i := start; i < lines + start; i++ {
        for j := 0; j < 1024; j++ {
            value, _, _, _ := (*oldImage).At(i, j).RGBA()
            var up, down, left, right uint32

            if i > 0 {
                up, _, _, _ = (*oldImage).At(i-1, j).RGBA()
            } else {
                up = 0
            }

            if i < 1023 {
                down, _, _, _ = (*oldImage).At(i+1, j).RGBA()
            } else {
                down = 0
            }

            if j > 0 {
                left, _, _, _ = (*oldImage).At(i, j-1).RGBA()
            } else {
                left = 0
            }

            if j < 1023 {
                right, _, _, _ = (*oldImage).At(i, j+1).RGBA()
            } else {
                right = 0
            }

            value = ((value * 6) + (up) + (right) + (left) + (down))/10

            newImage.SetGray(i, j, color.Gray{Y: (uint8)(value >> 8)})
        }
    }
}