package target

import (
	"debug/gosym"
	"fmt"
	"go/ast"
	"io"
	"time"

	"github.com/derekparker/delve/pkg/proc"
)

type Tracer struct {
	Target Interface

	Out io.Writer
}

func (t *Tracer) Pid() int {
	r := t.Target.Pid()
	fmt.Fprintf(t.Out, "[trace] Pid() -> %d\n", r)
	return r
}

func (t *Tracer) Exited() bool {
	r := t.Target.Exited()
	fmt.Fprintf(t.Out, "[trace] Exited() -> %v\n", r)
	return r
}

func (t *Tracer) Running() bool {
	r := t.Target.Running()
	fmt.Fprintf(t.Out, "[trace] Running() -> %v\n", r)
	return r
}

func (t *Tracer) LastModified() time.Time {
	r := t.Target.LastModified()
	fmt.Fprintf(t.Out, "[trace] LastModified() -> %v\n", r)
	return r
}

func (t *Tracer) Sources() map[string]*gosym.Obj {
	r := t.Target.Sources()
	fmt.Fprintf(t.Out, "[trace] Sources() -> %v\n", r)
	return r
}

func (t *Tracer) FindFileLocation(fileName string, lineNumber int) (uint64, error) {
	r, err := t.Target.FindFileLocation(fileName, lineNumber)
	fmt.Fprintf(t.Out, "[trace] FindFileLocation(%s, %d) -> (%d, %v)\n",
		fileName, lineNumber, r, err)
	return r, err
}

func (t *Tracer) FindFunctionLocation(funcName string, firstLine bool, lineOffset int) (uint64, error) {
	r, err := t.Target.FindFunctionLocation(funcName, firstLine, lineOffset)
	fmt.Fprintf(t.Out, "[trace] FindFunctionLocation(%s, %v, %d) -> (%d, %v)\n",
		funcName, firstLine, lineOffset, r, err)
	return r, err
}

func (t *Tracer) Funcs() []gosym.Func {
	r := t.Target.Funcs()
	fmt.Fprintf(t.Out, "[trace] Funcs() -> (%v)\n", r)
	return r
}

func (t *Tracer) Types() ([]string, error) {
	r, err := t.Target.Types()
	fmt.Fprintf(t.Out, "[trace] Types() -> (%v, %v)\n", r, err)
	return r, err
}

func (t *Tracer) PCToLine(p uint64) (string, int, *gosym.Func) {
	r1, r2, r3 := t.Target.PCToLine(p)
	fmt.Fprintf(t.Out, "[trace] PCToLine(%d) -> (%s, %d, %v)\n", p, r1, r2, r3)
	return r1, r2, r3
}

func (t *Tracer) FirstPCAfterPrologue(fn *gosym.Func, sameline bool) (uint64, error) {
	r, err := t.Target.FirstPCAfterPrologue(fn, sameline)
	fmt.Fprintf(t.Out, "[trace] FirstPCAfterPrologue(%v, %v) -> (%d, %v)\n",
		fn, sameline, r, err)
	return r, err
}

func (t *Tracer) Threads() map[int]*proc.Thread {
	r := t.Target.Threads()
	fmt.Fprintf(t.Out, "[trace] Threads() -> %v\n", r)
	return r
}

func (t *Tracer) CurrentThread() *proc.Thread {
	r := t.Target.CurrentThread()
	fmt.Fprintf(t.Out, "[trace] CurrentThread() -> %v\n", r)
	return r
}

func (t *Tracer) GoroutinesInfo() ([]*proc.G, error) {
	r, err := t.Target.GoroutinesInfo()
	fmt.Fprintf(t.Out, "[trace] GoroutinesInfo() -> (%v, %v)\n", r, err)
	return r, err
}

func (t *Tracer) SelectedGoroutine() *proc.G {
	r := t.Target.SelectedGoroutine()
	fmt.Fprintf(t.Out, "[trace] SelectedGoroutine() -> %v\n", r)
	return r
}

func (t *Tracer) FindGoroutine(g int) (*proc.G, error) {
	r, err := t.Target.FindGoroutine(g)
	fmt.Fprintf(t.Out, "[trace] FindGoroutine(%d) -> (%v, %v)\n", g, r, err)
	return r, err
}

func (t *Tracer) Continue() error {
	r := t.Target.Continue()
	fmt.Fprintf(t.Out, "[trace] Continue() -> %v\n", r)
	return r
}

func (t *Tracer) Next() error {
	r := t.Target.Next()
	fmt.Fprintf(t.Out, "[trace] Next() -> %v\n", r)
	return r
}

func (t *Tracer) Step() error {
	r := t.Target.Step()
	fmt.Fprintf(t.Out, "[trace] Step() -> %v\n", r)
	return r
}

func (t *Tracer) StepOut() error {
	r := t.Target.StepOut()
	fmt.Fprintf(t.Out, "[trace] StepOut() -> %v\n", r)
	return r
}

func (t *Tracer) StepInstruction() error {
	r := t.Target.StepInstruction()
	fmt.Fprintf(t.Out, "[trace] StepInstruction() -> %v\n", r)
	return r
}

func (t *Tracer) SwitchThread(a int) error {
	r := t.Target.SwitchThread(a)
	fmt.Fprintf(t.Out, "[trace] SwitchThread(%d) -> %v\n", a, r)
	return r
}

func (t *Tracer) SwitchGoroutine(a int) error {
	r := t.Target.SwitchGoroutine(a)
	fmt.Fprintf(t.Out, "[trace] SwitchGoroutine(%d) -> %v\n", a, r)
	return r
}
func (t *Tracer) RequestManualStop() error {
	r := t.Target.RequestManualStop()
	fmt.Fprintf(t.Out, "[trace] RequestManualStop() -> %v\n", r)
	return r
}

func (t *Tracer) Halt() error {
	r := t.Target.Halt()
	fmt.Fprintf(t.Out, "[trace] Halt() -> %v\n", r)
	return r
}

func (t *Tracer) Kill() error {
	r := t.Target.Kill()
	fmt.Fprintf(t.Out, "[trace] Kill() -> %v\n", r)
	return r
}

func (t *Tracer) Detach(a bool) error {
	r := t.Target.Detach(a)
	fmt.Fprintf(t.Out, "[trace] Detach(%v) -> %v\n", a, r)
	return r
}

func (t *Tracer) Breakpoints() map[uint64]*proc.Breakpoint {
	r := t.Target.Breakpoints()
	fmt.Fprintf(t.Out, "[trace] Breakpoints() -> %v\n", r)
	return r
}

func (t *Tracer) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error) {
	r, err := t.Target.SetBreakpoint(addr, kind, cond)
	fmt.Fprintf(t.Out, "[trace] SetBreakpoint(%x, %v, %v) -> (%v, %v)\n",
		addr, kind, cond, r, err)
	return r, err
}

func (t *Tracer) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) {
	r, err := t.Target.ClearBreakpoint(addr)
	fmt.Fprintf(t.Out, "[trace] ClearBreakpoint(%x) -> (%v, %v)\n", addr, r, err)
	return r, err
}

func (t *Tracer) ClearInternalBreakpoints() error {
	r := t.Target.ClearInternalBreakpoints()
	fmt.Fprintf(t.Out, "[trace] ClearInternalBreakpoints() -> %v\n", r)
	return r
}

func (t *Tracer) ConvertEvalScope(gid, frame int) (*proc.EvalScope, error) {
	r, err := t.Target.ConvertEvalScope(gid, frame)
	fmt.Fprintf(t.Out, "[trace] ConvertEvalScope(%d, %d) -> (%v, %v)\n",
		gid, frame, r, err)
	return r, err
}