package main

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

var str strings.Builder

func decode(encoded string, charNums []int) string {
    i, j, newChar := 0, 0, 0
    for {
        if encoded[i] == ' ' {
        //  fmt.Println("was a space")
            str.WriteString(" ")
            i += 1
            continue
        }
        newChar = int(encoded[i]) - charNums[j]
        if newChar < 97 {
            newChar = newChar + 26
        }
        str.WriteString(string(newChar))
        if i == len(encoded)-1 {
            break
        }
        if j == len(charNums)-1 {
            j = 0
            i += 1
            continue
        }
    //  fmt.Println(i, j)
        i += 1
        j += 1
    }
    return str.String()
}

func codeNumbers(code string, m map[string]int) []int {
    charNums := []int{}

    for _, v := range code {
    //  fmt.Println(v)
        if v == ' '{
            continue
        }
        if _, ok := m[string(v)]; ok {

            charNums = append(charNums, m[string(v)])
        } else {
            panic("Only alphabetical characters allowed!")
        }
    }
//  fmt.Println(charNums)
    return charNums
}

func messageNumbers(message string, m map[string]int) []int {
    charNums := []int{}

    for _, v := range message {
        fmt.Println(v)
        if _, ok := m[string(v)]; ok {
            charNums = append(charNums, m[string(v)])
        } else {
            panic("Only alphabetical characters allowed!")
        }
    }
//  fmt.Println(charNums)
    return charNums
}

func encode(message string, charNums []int) string {
    i, j, newChar := 0, 0, 0
    for {
        if message[i] == ' ' {
        //  fmt.Println("was a space")
            str.WriteString(" ")
            i += 1
            continue
        }
        newChar = int(message[i]) + charNums[j]
        if newChar > 122 {
            newChar = newChar - 26
        }
        str.WriteString(string(newChar))
        if i == len(message)-1 {
            break
        }
        if j == len(charNums)-1 {
            j = 0
            i += 1
            continue
        }
    //  fmt.Println(i, j)
        i += 1
        j += 1
    }
    return str.String()
}

func main() {
    reader := bufio.NewReader(os.Stdin)



    letters := map[string]int{
        "a": 0,
        "b": 1,
        "c": 2,
        "d": 3,
        "e": 4,
        "f": 5,
        "g": 6,
        "h": 7,
        "i": 8,
        "j": 9,
        "k": 10,
        "l": 11,
        "m": 12,
        "n": 13,
        "o": 14,
        "p": 15,
        "q": 16,
        "r": 17,
        "s": 18,
        "t": 19,
        "u": 20,
        "v": 21,
        "w": 22,
        "x": 23,
        "y": 24,
        "z": 25,
    }


    for{

        fmt.Print("Do you want to encode or decode? ")
        response, _ := reader.ReadString('\n')
        response = strings.ToLower(response[:len(response)-2])
        if response == "encode"{
            fmt.Print("Enter message, Alphabetical characters only: ")
            message, _ := reader.ReadString('\n')

            message = strings.ToLower(message[:len(message)-2])

            fmt.Print("Enter code, Alphabetical characters only: ")
            code, _ := reader.ReadString('\n')

            code = strings.ToLower(code[:len(code)-2])
            codeNums := codeNumbers(code, letters)
            fmt.Println("Here is your message encoded:", encode(message, codeNums))
            break

        }else if response == "decode"{
            fmt.Print("Enter encoded message, Alphabetical characters only: ")
            encMessage, _ := reader.ReadString('\n')

            encMessage = strings.ToLower(encMessage[:len(encMessage)-2])

            fmt.Print("Enter code, Alphabetical characters only: ")
            code, _ := reader.ReadString('\n')

            code = strings.ToLower(code[:len(code)-2])
            codeNums := codeNumbers(code, letters)
            fmt.Println("Here is your encoded message decoded: ", decode(encMessage, codeNums))
            break

        }else{
            fmt.Println("Enter either \"encode\" or \"decode\"")
            break
        }
    }
}