package libs

import (
	"encoding/json"
	"fmt"
	"time"
)

// UiObject 表示一个 Android UI 控件对象
// 通过 Selector 定位，支持点击、输入、滑动等操作
// 对应 Python 版本的 UiObject 类
type UiObject struct {
	device   *Device
	selector *Selector
	jsonrpc  *JsonRpcWrapper
}

// NewUiObject 创建一个新的 UiObject
func NewUiObject(device *Device, selector *Selector) *UiObject {
	return &UiObject{
		device:   device,
		selector: selector,
		jsonrpc:  device.JsonRpc(),
	}
}

// Selector 返回当前 UiObject 的选择器
func (u *UiObject) Selector() *Selector {
	return u.selector
}

// ---------- 等待和存在性 ----------

// Exists 检查 UI 元素是否存在于当前窗口
func (u *UiObject) Exists() (bool, error) {
	raw, err := u.jsonrpc.Call("objInfo", []interface{}{u.selector.ToMap()}, 10)
	if err != nil {
		// UiObjectNotFoundError 意味着不存在
		if _, ok := err.(*UiObjectNotFoundError); ok {
			return false, nil
		}
		return false, err
	}
	return raw != nil, nil
}

// Wait 等待 UI 元素出现或消失
// exists: true 等待出现，false 等待消失
// timeout: 超时时间（秒），0 使用默认值
//
// 通过 JSON-RPC 调用服务端的 waitForExists/waitUntilGone 实现
// 使用 adb forward 端口转发，连接稳定，与 Python 版本行为一致
func (u *UiObject) Wait(exists bool, timeout float64) (bool, error) {
	if timeout <= 0 {
		timeout = u.device.WaitTimeout()
	}
	if timeout <= 0 {
		timeout = 10.0
	}
	httpWait := timeout + 10

	if exists {
		raw, err := u.jsonrpc.Call("waitForExists", []interface{}{u.selector.ToMap(), int(timeout * 1000)}, httpWait)
		if err != nil {
			// HTTP 超时时回退到 Exists 检查
			if _, ok := err.(*HTTPError); ok {
				ex, _ := u.Exists()
				return ex, nil
			}
			return false, err
		}
		var result bool
		json.Unmarshal(raw, &result)
		return result, nil
	}

	// 等待消失
	raw, err := u.jsonrpc.Call("waitUntilGone", []interface{}{u.selector.ToMap(), int(timeout * 1000)}, httpWait)
	if err != nil {
		if _, ok := err.(*HTTPError); ok {
			ex, _ := u.Exists()
			return !ex, nil
		}
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// WaitGone 等待 UI 元素消失
func (u *UiObject) WaitGone(timeout float64) (bool, error) {
	return u.Wait(false, timeout)
}

// MustWait 等待元素出现，不存在则返回 UiObjectNotFoundError
func (u *UiObject) MustWait(timeout float64) error {
	found, err := u.Wait(true, timeout)
	if err != nil {
		return err
	}
	if !found {
		return &UiObjectNotFoundError{
			Code:    -32002,
			Message: fmt.Sprintf("等待超时: %s", u.selector.String()),
			Params:  u.selector.ToMap(),
		}
	}
	return nil
}

// ---------- 元素信息 ----------

// ObjInfo 包含 UI 元素的详细信息
type ObjInfo struct {
	Text               string                 `json:"text"`
	ClassName          string                 `json:"className"`
	ContentDescription string                 `json:"contentDescription"`
	PackageName        string                 `json:"packageName"`
	ResourceName       string                 `json:"resourceName"`
	Checkable          bool                   `json:"checkable"`
	Checked            bool                   `json:"checked"`
	Clickable          bool                   `json:"clickable"`
	Enabled            bool                   `json:"enabled"`
	Focusable          bool                   `json:"focusable"`
	Focused            bool                   `json:"focused"`
	LongClickable      bool                   `json:"longClickable"`
	Scrollable         bool                   `json:"scrollable"`
	Selected           bool                   `json:"selected"`
	Bounds             map[string]int         `json:"bounds"`
	VisibleBounds      map[string]int         `json:"visibleBounds"`
	ChildCount         int                    `json:"childCount"`
	Extra              map[string]interface{} `json:"-"` // 额外字段
}

// Info 获取 UI 元素信息
func (u *UiObject) Info() (*ObjInfo, error) {
	raw, err := u.jsonrpc.Call("objInfo", []interface{}{u.selector.ToMap()})
	if err != nil {
		return nil, err
	}
	var info ObjInfo
	if err := json.Unmarshal(raw, &info); err != nil {
		return nil, err
	}
	return &info, nil
}

// InfoRaw 获取 UI 元素的原始 map 信息
func (u *UiObject) InfoRaw() (map[string]interface{}, error) {
	raw, err := u.jsonrpc.Call("objInfo", []interface{}{u.selector.ToMap()})
	if err != nil {
		return nil, err
	}
	var info map[string]interface{}
	if err := json.Unmarshal(raw, &info); err != nil {
		return nil, err
	}
	return info, nil
}

// InfoList 获取所有匹配元素的信息列表
func (u *UiObject) InfoList() ([]map[string]interface{}, error) {
	raw, err := u.jsonrpc.Call("objInfoOfAllInstances", []interface{}{u.selector.ToMap()})
	if err != nil {
		return nil, err
	}
	var list []map[string]interface{}
	if err := json.Unmarshal(raw, &list); err != nil {
		return nil, err
	}
	return list, nil
}

// ---------- 边界和坐标 ----------

// Bounds 获取元素的边界坐标 (left, top, right, bottom)
func (u *UiObject) Bounds() (int, int, int, int, error) {
	info, err := u.InfoRaw()
	if err != nil {
		return 0, 0, 0, 0, err
	}

	// 优先使用 visibleBounds
	bounds, ok := info["visibleBounds"].(map[string]interface{})
	if !ok {
		bounds, ok = info["bounds"].(map[string]interface{})
		if !ok {
			return 0, 0, 0, 0, fmt.Errorf("无法获取元素边界")
		}
	}

	lx := int(bounds["left"].(float64))
	ly := int(bounds["top"].(float64))
	rx := int(bounds["right"].(float64))
	ry := int(bounds["bottom"].(float64))
	return lx, ly, rx, ry, nil
}

// Center 获取元素中心坐标
// offset: [xoff, yoff]，(0,0) 表示左上角，(0.5,0.5) 表示中心
func (u *UiObject) Center(offset ...float64) (int, int, error) {
	xoff, yoff := 0.5, 0.5
	if len(offset) >= 2 {
		xoff, yoff = offset[0], offset[1]
	}

	lx, ly, rx, ry, err := u.Bounds()
	if err != nil {
		return 0, 0, err
	}

	width := rx - lx
	height := ry - ly
	x := lx + int(float64(width)*xoff)
	y := ly + int(float64(height)*yoff)
	return x, y, nil
}

// ---------- 点击操作 ----------

// Click 点击 UI 元素
// timeout: 等待元素出现的超时时间（秒），0 使用默认值
func (u *UiObject) Click(timeout ...float64) error {
	t := 0.0
	if len(timeout) > 0 {
		t = timeout[0]
	}

	if err := u.MustWait(t); err != nil {
		return err
	}

	x, y, err := u.Center()
	if err != nil {
		return err
	}
	return u.device.Click(x, y)
}

// ClickWithOffset 带偏移量点击 UI 元素
func (u *UiObject) ClickWithOffset(xoff, yoff float64, timeout ...float64) error {
	t := 0.0
	if len(timeout) > 0 {
		t = timeout[0]
	}

	if err := u.MustWait(t); err != nil {
		return err
	}

	x, y, err := u.Center(xoff, yoff)
	if err != nil {
		return err
	}
	return u.device.Click(x, y)
}

// ClickExists 如果元素存在则点击，返回是否成功
func (u *UiObject) ClickExists(timeout ...float64) bool {
	t := 0.0
	if len(timeout) > 0 {
		t = timeout[0]
	}
	err := u.Click(t)
	return err == nil
}

// ClickGone 持续点击直到元素消失
// maxRetry: 最大重试次数
// interval: 重试间隔（秒）
func (u *UiObject) ClickGone(maxRetry int, interval float64) bool {
	if maxRetry <= 0 {
		maxRetry = 10
	}
	if interval <= 0 {
		interval = 1.0
	}

	u.ClickExists(0)
	for i := 0; i < maxRetry; i++ {
		time.Sleep(time.Duration(interval * float64(time.Second)))
		exists, _ := u.Exists()
		if !exists {
			return true
		}
		u.ClickExists(0)
	}
	return false
}

// LongClick 长按 UI 元素
// duration: 按住时间（秒），默认 0.5
func (u *UiObject) LongClick(duration float64, timeout ...float64) error {
	if duration <= 0 {
		duration = 0.5
	}
	t := 0.0
	if len(timeout) > 0 {
		t = timeout[0]
	}

	if err := u.MustWait(t); err != nil {
		return err
	}

	x, y, err := u.Center()
	if err != nil {
		return err
	}
	return u.device.LongClick(x, y, duration)
}

// ---------- 文本操作 ----------

// GetText 获取元素文本内容
func (u *UiObject) GetText(timeout ...float64) (string, error) {
	t := 0.0
	if len(timeout) > 0 {
		t = timeout[0]
	}
	if err := u.MustWait(t); err != nil {
		return "", err
	}

	raw, err := u.jsonrpc.Call("getText", []interface{}{u.selector.ToMap()})
	if err != nil {
		return "", err
	}
	var text string
	json.Unmarshal(raw, &text)
	return text, nil
}

// SetText 设置元素文本内容
// 如果 text 为空，则清除文本
func (u *UiObject) SetText(text string, timeout ...float64) error {
	t := 0.0
	if len(timeout) > 0 {
		t = timeout[0]
	}
	if err := u.MustWait(t); err != nil {
		return err
	}

	if text == "" {
		_, err := u.jsonrpc.Call("clearTextField", []interface{}{u.selector.ToMap()})
		return err
	}
	_, err := u.jsonrpc.Call("setText", []interface{}{u.selector.ToMap(), text})
	return err
}

// ClearText 清除元素文本
func (u *UiObject) ClearText(timeout ...float64) error {
	return u.SetText("", timeout...)
}

// SendKeys SetText 的别名
func (u *UiObject) SendKeys(text string, timeout ...float64) error {
	return u.SetText(text, timeout...)
}

// ---------- 滑动操作 ----------

// UiSwipe 在元素范围内滑动
// direction: 方向 "left"/"right"/"up"/"down"
// steps: 滑动步数
func (u *UiObject) UiSwipe(direction string, steps int) error {
	if steps <= 0 {
		steps = 10
	}

	if err := u.MustWait(0); err != nil {
		return err
	}

	lx, ly, rx, ry, err := u.Bounds()
	if err != nil {
		return err
	}

	cx := (lx + rx) / 2
	cy := (ly + ry) / 2

	switch direction {
	case "up":
		return u.device.Swipe(cx, cy, cx, ly, steps)
	case "down":
		return u.device.Swipe(cx, cy, cx, ry-1, steps)
	case "left":
		return u.device.Swipe(cx, cy, lx, cy, steps)
	case "right":
		return u.device.Swipe(cx, cy, rx-1, cy, steps)
	default:
		return fmt.Errorf("不支持的方向: %s", direction)
	}
}

// DragTo 将元素拖拽到指定坐标
func (u *UiObject) DragTo(x, y int, duration float64, timeout ...float64) error {
	if duration <= 0 {
		duration = 0.5
	}
	t := 0.0
	if len(timeout) > 0 {
		t = timeout[0]
	}
	if err := u.MustWait(t); err != nil {
		return err
	}

	steps := int(duration * 200)
	_, err := u.jsonrpc.Call("dragTo", []interface{}{u.selector.ToMap(), x, y, steps})
	return err
}

// ---------- 手势操作 ----------

// PinchIn 向内捏合（缩小）
func (u *UiObject) PinchIn(percent, steps int) error {
	if percent <= 0 {
		percent = 100
	}
	if steps <= 0 {
		steps = 50
	}
	_, err := u.jsonrpc.Call("pinchIn", []interface{}{u.selector.ToMap(), percent, steps})
	return err
}

// PinchOut 向外捏合（放大）
func (u *UiObject) PinchOut(percent, steps int) error {
	if percent <= 0 {
		percent = 100
	}
	if steps <= 0 {
		steps = 50
	}
	_, err := u.jsonrpc.Call("pinchOut", []interface{}{u.selector.ToMap(), percent, steps})
	return err
}

// ---------- 子/兄弟元素 ----------

// Child 查找子元素
func (u *UiObject) Child(params map[string]interface{}) (*UiObject, error) {
	sel := u.selector.Clone()
	if _, err := sel.Child(params); err != nil {
		return nil, err
	}
	return NewUiObject(u.device, sel), nil
}

// Sibling 查找兄弟元素
func (u *UiObject) Sibling(params map[string]interface{}) (*UiObject, error) {
	sel := u.selector.Clone()
	if _, err := sel.Sibling(params); err != nil {
		return nil, err
	}
	return NewUiObject(u.device, sel), nil
}

// ChildByText 通过文本查找子元素
func (u *UiObject) ChildByText(text string, params map[string]interface{}) (*UiObject, error) {
	childSel, err := New(params)
	if err != nil {
		return nil, err
	}
	raw, err := u.jsonrpc.Call("childByText", []interface{}{u.selector.ToMap(), childSel.ToMap(), text})
	if err != nil {
		return nil, err
	}
	var resultMap map[string]interface{}
	if err := json.Unmarshal(raw, &resultMap); err != nil {
		return nil, err
	}
	resultSel, err := FromMap(resultMap)
	if err != nil {
		return nil, err
	}
	return NewUiObject(u.device, resultSel), nil
}

// ChildByDescription 通过描述查找子元素
func (u *UiObject) ChildByDescription(desc string, params map[string]interface{}) (*UiObject, error) {
	childSel, err := New(params)
	if err != nil {
		return nil, err
	}
	raw, err := u.jsonrpc.Call("childByDescription", []interface{}{u.selector.ToMap(), childSel.ToMap(), desc})
	if err != nil {
		return nil, err
	}
	var resultMap map[string]interface{}
	if err := json.Unmarshal(raw, &resultMap); err != nil {
		return nil, err
	}
	resultSel, err := FromMap(resultMap)
	if err != nil {
		return nil, err
	}
	return NewUiObject(u.device, resultSel), nil
}

// ---------- 数量和索引 ----------

// Count 获取匹配元素的数量
func (u *UiObject) Count() (int, error) {
	raw, err := u.jsonrpc.Call("count", []interface{}{u.selector.ToMap()})
	if err != nil {
		return 0, err
	}
	var count int
	json.Unmarshal(raw, &count)
	return count, nil
}

// Instance 获取指定索引的元素
func (u *UiObject) Instance(index int) *UiObject {
	sel := u.selector.Clone()
	if index < 0 {
		// 负数索引需要先获取总数
		count, err := u.Count()
		if err == nil && index+count >= 0 {
			index = index + count
		} else {
			index = 0
		}
	}
	sel.UpdateInstance(index)
	return NewUiObject(u.device, sel)
}

// ---------- 滚动操作 ----------

// ScrollForward 向前滚动
func (u *UiObject) ScrollForward(vertical bool, steps int) (bool, error) {
	if steps <= 0 {
		steps = ScrollSteps
	}
	raw, err := u.jsonrpc.Call("scrollForward", []interface{}{u.selector.ToMap(), vertical, steps})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// ScrollBackward 向后滚动
func (u *UiObject) ScrollBackward(vertical bool, steps int) (bool, error) {
	if steps <= 0 {
		steps = ScrollSteps
	}
	raw, err := u.jsonrpc.Call("scrollBackward", []interface{}{u.selector.ToMap(), vertical, steps})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// ScrollToBeginning 滚动到开头
func (u *UiObject) ScrollToBeginning(vertical bool, maxSwipes, steps int) (bool, error) {
	if maxSwipes <= 0 {
		maxSwipes = 500
	}
	if steps <= 0 {
		steps = ScrollSteps
	}
	raw, err := u.jsonrpc.Call("scrollToBeginning", []interface{}{u.selector.ToMap(), vertical, maxSwipes, steps})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// ScrollToEnd 滚动到末尾
func (u *UiObject) ScrollToEnd(vertical bool, maxSwipes, steps int) (bool, error) {
	if maxSwipes <= 0 {
		maxSwipes = 500
	}
	if steps <= 0 {
		steps = ScrollSteps
	}
	raw, err := u.jsonrpc.Call("scrollToEnd", []interface{}{u.selector.ToMap(), vertical, maxSwipes, steps})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// ScrollTo 滚动到指定元素可见
func (u *UiObject) ScrollTo(targetParams map[string]interface{}, vertical bool) (bool, error) {
	targetSel, err := New(targetParams)
	if err != nil {
		return false, err
	}
	raw, err := u.jsonrpc.Call("scrollTo", []interface{}{u.selector.ToMap(), targetSel.ToMap(), vertical})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// ---------- Fling 操作 ----------

// FlingForward 向前快速滑动
func (u *UiObject) FlingForward(vertical bool) (bool, error) {
	raw, err := u.jsonrpc.Call("flingForward", []interface{}{u.selector.ToMap(), vertical})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// FlingBackward 向后快速滑动
func (u *UiObject) FlingBackward(vertical bool) (bool, error) {
	raw, err := u.jsonrpc.Call("flingBackward", []interface{}{u.selector.ToMap(), vertical})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// FlingToBeginning 快速滑动到开头
func (u *UiObject) FlingToBeginning(vertical bool, maxSwipes int) (bool, error) {
	if maxSwipes <= 0 {
		maxSwipes = 500
	}
	raw, err := u.jsonrpc.Call("flingToBeginning", []interface{}{u.selector.ToMap(), vertical, maxSwipes})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}

// FlingToEnd 快速滑动到末尾
func (u *UiObject) FlingToEnd(vertical bool, maxSwipes int) (bool, error) {
	if maxSwipes <= 0 {
		maxSwipes = 500
	}
	raw, err := u.jsonrpc.Call("flingToEnd", []interface{}{u.selector.ToMap(), vertical, maxSwipes})
	if err != nil {
		return false, err
	}
	var result bool
	json.Unmarshal(raw, &result)
	return result, nil
}