package main

import (
    "bytes"
    "errors"
    "fmt"
    "log"
    "net"
    "strings"
)

var ErrPingFailed = errors.New("Ping Failed")

type RedisClient struct {
    conn net.Conn
}

func NewRedisClient() *RedisClient {
    return &RedisClient{}
}

func (r *RedisClient) Ping() (bool, error) {

    _, err := r.conn.Write([]byte("PING\r\n"))

    if err != nil {
        return false, err
    }

    buf := make([]byte, 5)

    _, err = r.conn.Read(buf)

    if err != nil {
        return false, err
    }

    if !bytes.Equal(buf, []byte("+PONG")) {
        return false, ErrPingFailed
    }

    return true, nil
}

func (r *RedisClient) Connect() error {

    conn, err := net.Dial("tcp", ":6379")

    if err != nil {
        return err
    }

    r.conn = conn
    return nil
}

func Format(strs ...string) string {

    str := fmt.Sprintf("*%d\r\n", len(strs))

    for _, s := range strs {
        str += fmt.Sprintf("$%d\r\n%s\r\n", len(s), s)
    }

    return str
}

func (r *RedisClient) Set(k string, v string) error {

    _, err := r.conn.Write([]byte(Format("SET", k, v)))
    return err
}

func (r *RedisClient) Get(k string) (string, error) {

    buf := make([]byte, 255)

    _, err := r.conn.Write([]byte(Format("GET", k)))

    if err != nil {
        return "", err
    }

    n, err := r.conn.Read(buf)

    if err != nil {
        return "", err
    }

    resp := strings.Split(string(buf[:n]), "\r\n")

    return resp[3], nil
}

func main() {

    r := NewRedisClient()

    err := r.Connect()

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

    ok, _ := r.Ping()

    fmt.Println(ok)

    err = r.Set("Hello", "World")

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

    v, err := r.Get("Hello")

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

    fmt.Printf("value: %s", v)
}