package main

import (
	"bufio"
	"bytes"
	"crypto/sha256"
	"encoding/json"
	"errors"
	"fmt"
	"image"
	"image/jpeg"
	"image/png"
	"net"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"sync/atomic"
	"time"
)

type settings struct {
	Address, Instance, Token, Chat, CancelChat, EmptyCancelChat string
}
type status struct {
	HTTP      int     `json:"http_status"`
	Instance  string  `json:"instance"`
	Code      string  `json:"error_code,omitempty"`
	Retry     string  `json:"retry_after,omitempty"`
	SHA       string  `json:"sha256,omitempty"`
	Size      int     `json:"size_bytes,omitempty"`
	RequestID string  `json:"request_id,omitempty"`
	Elapsed   float64 `json:"elapsed_seconds"`
}
type event map[string]any

var events []event

func record(name string, data any) {
	events = append(events, event{"event": name, "time_utc": time.Now().UTC().Format(time.RFC3339Nano), "data": data})
}
func check(ok bool, description string) error {
	if !ok {
		return errors.New(description)
	}
	return nil
}
func decode(resp *http.Response, start time.Time) (status, error) {
	defer resp.Body.Close()
	var value struct {
		Error struct {
			Code string `json:"code"`
		} `json:"error"`
		SHA  string `json:"sha256"`
		Size int    `json:"size_bytes"`
	}
	err := json.NewDecoder(resp.Body).Decode(&value)
	return status{HTTP: resp.StatusCode, Instance: resp.Header.Get("X-Instance-Id"), Retry: resp.Header.Get("Retry-After"),
		Code: value.Error.Code, SHA: value.SHA, Size: value.Size, RequestID: resp.Header.Get("X-Request-Id"), Elapsed: time.Since(start).Seconds()}, err
}
func path(chat, filename string) string {
	return "/api/v1/chats/" + chat + "/attachments?filename=" + filename
}
func post(c settings, filename, mime string, body []byte) (status, error) {
	start := time.Now()
	req, err := http.NewRequest("POST", "http://"+c.Address+path(c.Chat, filename), bytes.NewReader(body))
	if err != nil {
		return status{}, err
	}
	req.Header.Set("Content-Type", mime)
	req.Header.Set("Authorization", "Bearer "+c.Token)
	// One connection per upload makes the simultaneous requests independent.
	req.Close = true
	resp, err := (&http.Client{Timeout: 12 * time.Second}).Do(req)
	if err != nil {
		return status{Elapsed: time.Since(start).Seconds()}, err
	}
	return decode(resp, start)
}

type pending struct {
	conn   net.Conn
	reader *bufio.Reader
	start  time.Time
}

func begin(c settings, chat, filename string, length int, expect bool) (*pending, error) {
	conn, err := net.DialTimeout("tcp", c.Address, 2*time.Second)
	if err != nil {
		return nil, err
	}
	conn.SetDeadline(time.Now().Add(8 * time.Second))
	expectation := ""
	if expect {
		expectation = "Expect: 100-continue\r\n"
	}
	_, err = fmt.Fprintf(conn, "POST %s HTTP/1.1\r\nHost: %s\r\nAuthorization: Bearer %s\r\nContent-Type: image/png\r\nContent-Length: %d\r\n%sConnection: close\r\n\r\n", path(chat, filename), c.Address, c.Token, length, expectation)
	if err != nil {
		conn.Close()
		return nil, err
	}
	return &pending{conn, bufio.NewReader(conn), time.Now()}, nil
}
func (p *pending) provisional() error {
	response, err := http.ReadResponse(p.reader, nil)
	if err != nil {
		return err
	}
	response.Body.Close()
	return check(response.StatusCode == 100, fmt.Sprintf("expected provisional 100, got %d", response.StatusCode))
}
func (p *pending) finish(body []byte) (status, error) {
	if _, err := p.conn.Write(body); err != nil {
		return status{}, err
	}
	response, err := http.ReadResponse(p.reader, nil)
	if err != nil {
		return status{}, err
	}
	return decode(response, p.start)
}
func valid(value status, expectedInstance string, payload []byte) error {
	return check(value.HTTP == 201 && (expectedInstance == "" || value.Instance == expectedInstance) &&
		value.SHA == fmt.Sprintf("%x", sha256.Sum256(payload)) && value.Size == len(payload) &&
		value.RequestID != "", fmt.Sprintf("expected valid 201 from %s, got %d from %s", expectedInstance, value.HTTP, value.Instance))
}
func controlled(c settings) error {
	body, err := os.ReadFile("/input/sample.png")
	if err != nil {
		return err
	}
	first, err := begin(c, c.Chat, "held-a.png", len(body), true)
	if err != nil {
		return err
	}
	defer first.conn.Close()
	if err := first.provisional(); err != nil {
		return err
	}
	second, err := begin(c, c.Chat, "held-b.png", len(body), true)
	if err != nil {
		return err
	}
	defer second.conn.Close()
	if err := second.provisional(); err != nil {
		return err
	}
	record("both_slots_held", event{"provisional_statuses": []int{100, 100}, "body_bytes_sent": 0})
	limited, err := post(c, "limited.png", "image/png", body)
	record("third_upload", limited)
	if err != nil {
		return err
	}
	if err := check(limited.HTTP == 429 && limited.Code == "rate_limited" && limited.Retry == "1" &&
		limited.Instance == c.Instance && limited.RequestID != "" && limited.Elapsed >= .9 && limited.Elapsed <= 1.5,
		"third upload did not return the expected 429, Retry-After and one-second wait"); err != nil {
		return err
	}
	for _, cancel := range []struct {
		chat string
		size int
	}{
		{c.CancelChat, len(body)}, {c.EmptyCancelChat, 0},
	} {
		waiter, err := begin(c, cancel.chat, "cancel.png", cancel.size, false)
		if err != nil {
			return err
		}
		time.Sleep(220 * time.Millisecond)
		waiter.conn.Close()
		record("waiter_disconnected", event{"chat_id": cancel.chat, "declared_bytes": cancel.size, "body_bytes_sent": 0,
			"disconnect_after_seconds": time.Since(waiter.start).Seconds()})
	}
	// Both slots stay occupied for longer than the wait timeout, so server logs
	// distinguish cancellation from a later slot grant.
	time.Sleep(1150 * time.Millisecond)
	r, err := first.finish(body)
	record("first_holder_finished", r)
	if err != nil {
		return err
	}
	if err := valid(r, c.Instance, body); err != nil {
		return err
	}
	r, err = post(c, "after-release.png", "image/png", body)
	record("upload_after_release", r)
	if err != nil {
		return err
	}
	if err := valid(r, c.Instance, body); err != nil {
		return err
	}
	r, err = second.finish(body)
	record("second_holder_finished", r)
	if err != nil {
		return err
	}
	return valid(r, c.Instance, body)
}
func load(c settings) error {
	pngData, err := os.ReadFile("/input/load.png")
	if err != nil {
		return err
	}
	jpegData, err := os.ReadFile("/input/load.jpg")
	if err != nil {
		return err
	}
	payloads := []struct {
		name, mime string
		data       []byte
	}{{"load.png", "image/png", pngData}, {"load.jpg", "image/jpeg", jpegData}}
	const count = 12
	var wg, ready sync.WaitGroup
	var active, peak atomic.Int32
	start := make(chan struct{})
	done := make(chan event, count)
	for i := 0; i < count; i++ {
		wg.Add(1)
		ready.Add(1)
		go func(i int) {
			defer wg.Done()
			p := payloads[i%len(payloads)]
			ready.Done()
			<-start
			n := active.Add(1)
			for current := peak.Load(); n > current && !peak.CompareAndSwap(current, n); current = peak.Load() {
			}
			value, err := post(c, p.name, p.mime, p.data)
			active.Add(-1)
			detail := event{"request": i + 1, "file": p.name, "response": value}
			if err == nil {
				if value.HTTP == 201 {
					err = valid(value, "", p.data)
				} else if value.HTTP == 429 {
					err = check(value.Code == "rate_limited" && value.Retry == "1" && value.Instance != "" && value.RequestID != "", "invalid rate limit response")
				} else {
					err = fmt.Errorf("unexpected status %d", value.HTTP)
				}
			}
			if err != nil {
				detail["failure"] = err.Error()
			}
			done <- detail
		}(i)
	}
	ready.Wait()
	close(start)
	wg.Wait()
	close(done)
	failures := 0
	for detail := range done {
		record("concurrent_response", detail)
		if detail["failure"] != nil {
			failures++
		}
	}
	record("concurrent_peak", event{"workers": count, "client_in_flight_peak": peak.Load()})
	return check(peak.Load() >= 10 && failures == 0, "load had fewer than 10 overlapping requests or contained unexpected responses")
}
func generate(directory string) error {
	const width, height = 6000, 6000
	img := image.NewNRGBA(image.Rect(0, 0, width, height))
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			i := y*img.Stride + x*4
			img.Pix[i] = byte(x/12 + y/36)
			img.Pix[i+1] = byte(x/24 - y/9)
			img.Pix[i+2] = byte((x / 8) ^ (y / 16))
			img.Pix[i+3] = 255
		}
	}
	for _, name := range []string{"load.png", "load.jpg"} {
		f, err := os.Create(filepath.Join(directory, name))
		if err != nil {
			return err
		}
		if strings.HasSuffix(name, "png") {
			err = png.Encode(f, img)
		} else {
			err = jpeg.Encode(f, img, &jpeg.Options{Quality: 90})
		}
		f.Close()
		if err != nil {
			return err
		}
	}
	return nil
}
func main() {
	if len(os.Args) != 2 {
		os.Exit(2)
	}
	if os.Args[1] == "generate" {
		if err := generate("."); err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(1)
		}
		return
	}
	var c settings
	if err := json.NewDecoder(os.Stdin).Decode(&c); err != nil {
		os.Exit(2)
	}
	var err error
	switch os.Args[1] {
	case "controlled":
		err = controlled(c)
	case "load":
		err = load(c)
	default:
		err = errors.New("unknown mode")
	}
	report := event{"events": events}
	if err != nil {
		report["failure"] = err.Error()
	}
	json.NewEncoder(os.Stdout).Encode(report)
	if err != nil {
		os.Exit(1)
	}
}
