package uixt

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"net"
	"net/http"
	"net/url"
	"path"
	"strings"
	"time"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

type DriverSession struct {
	ID string
	// cache uia2/wda request and response
	requests []*DriverResult
	// cache screenshot ocr results
	screenResults []*ScreenResult // list of actions
	// cache e2e delay
	e2eDelay []timeLog
}

func (d *DriverSession) addScreenResult(screenResult *ScreenResult) {
	d.screenResults = append(d.screenResults, screenResult)
}

func (d *DriverSession) addRequestResult(driverResult *DriverResult) {
	d.requests = append(d.requests, driverResult)
}

func (d *DriverSession) Reset() {
	d.screenResults = make([]*ScreenResult, 0)
	d.requests = make([]*DriverResult, 0)
	d.e2eDelay = nil
}

type Attachments map[string]interface{}

func (d *DriverSession) Get(withReset bool) Attachments {
	data := Attachments{
		"screen_results": d.screenResults,
	}
	if len(d.requests) != 0 {
		data["requests"] = d.requests
	}
	if d.e2eDelay != nil {
		data["e2e_results"] = d.e2eDelay
	}
	if withReset {
		d.Reset()
	}
	return data
}

type Driver struct {
	urlPrefix *url.URL
	client    *http.Client

	// cache to avoid repeated query
	scale         float64
	windowSize    Size
	driverResults []*DriverResult

	// cache session data
	session DriverSession
}

type DriverResult struct {
	RequestMethod string    `json:"request_method"`
	RequestUrl    string    `json:"request_url"`
	RequestBody   string    `json:"request_body,omitempty"`
	RequestTime   time.Time `json:"request_time"`

	Success          bool   `json:"success"`
	ResponseStatus   int    `json:"response_status"`
	ResponseDuration int64  `json:"response_duration(ms)"` // ms
	ResponseBody     string `json:"response_body"`
	Error            string `json:"error,omitempty"`
}

func (wd *Driver) concatURL(u *url.URL, elem ...string) string {
	var tmp *url.URL
	if u == nil {
		u = wd.urlPrefix
	}
	tmp, _ = url.Parse(u.String())
	tmp.Path = path.Join(append([]string{u.Path}, elem...)...)
	return tmp.String()
}

func (wd *Driver) GET(pathElem ...string) (rawResp rawResponse, err error) {
	return wd.Request(http.MethodGet, wd.concatURL(nil, pathElem...), nil)
}

func (wd *Driver) POST(data interface{}, pathElem ...string) (rawResp rawResponse, err error) {
	var bsJSON []byte = nil
	if data != nil {
		if bsJSON, err = json.Marshal(data); err != nil {
			return nil, err
		}
	}
	return wd.Request(http.MethodPost, wd.concatURL(nil, pathElem...), bsJSON)
}

func (wd *Driver) DELETE(pathElem ...string) (rawResp rawResponse, err error) {
	return wd.Request(http.MethodDelete, wd.concatURL(nil, pathElem...), nil)
}

func (wd *Driver) Request(method string, rawURL string, rawBody []byte) (rawResp rawResponse, err error) {
	driverResult := &DriverResult{
		RequestMethod: method,
		RequestUrl:    rawURL,
		RequestBody:   string(rawBody),
	}

	defer func() {
		wd.session.addRequestResult(driverResult)

		var logger *zerolog.Event
		if err != nil {
			driverResult.Success = false
			driverResult.Error = err.Error()
			logger = log.Error().Bool("success", false).Err(err)
		} else {
			driverResult.Success = true
			logger = log.Debug().Bool("success", true)
		}

		logger = logger.Str("request_method", method).Str("request_url", rawURL).
			Str("request_body", string(rawBody))
		if !driverResult.RequestTime.IsZero() {
			logger = logger.Int64("request_time", driverResult.RequestTime.UnixMilli())
		}
		if driverResult.ResponseStatus != 0 {
			logger = logger.
				Int("response_status", driverResult.ResponseStatus).
				Int64("response_duration(ms)", driverResult.ResponseDuration).
				Str("response_body", driverResult.ResponseBody)
		}
		logger.Msg("request uixt driver")
	}()

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	var req *http.Request
	if req, err = http.NewRequestWithContext(ctx, method, rawURL, bytes.NewBuffer(rawBody)); err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
	req.Header.Set("Accept", "application/json")

	driverResult.RequestTime = time.Now()
	var resp *http.Response
	if resp, err = wd.client.Do(req); err != nil {
		return nil, err
	}
	defer func() {
		// https://github.com/etcd-io/etcd/blob/v3.3.25/pkg/httputil/httputil.go#L16-L22
		_, _ = io.Copy(io.Discard, resp.Body)
		_ = resp.Body.Close()
	}()

	rawResp, err = io.ReadAll(resp.Body)
	duration := time.Since(driverResult.RequestTime)
	driverResult.ResponseDuration = duration.Milliseconds()
	driverResult.ResponseStatus = resp.StatusCode

	if strings.HasSuffix(rawURL, "screenshot") {
		// avoid printing screenshot data
		driverResult.ResponseBody = "OMITTED"
	} else {
		driverResult.ResponseBody = string(rawResp)
	}
	if err != nil {
		return nil, err
	}

	if err = rawResp.checkErr(); err != nil {
		if resp.StatusCode == http.StatusOK {
			return rawResp, nil
		}
		return nil, err
	}

	return
}

func convertToHTTPClient(conn net.Conn) *http.Client {
	return &http.Client{
		Transport: &http.Transport{
			DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
				return conn, nil
			},
		},
		Timeout: 30 * time.Second,
	}
}