// Copyright (c) Meta Platforms, Inc. and affiliates.
// SPDX-License-Identifier: LGPL-2.1-or-later

#include "drgnpy.h"
#include "../stack_trace.h"
#include "../util.h"

PyObject *StackTrace_wrap(struct drgn_stack_trace *trace) {
	StackTrace *ret = call_tp_alloc(StackTrace);
	if (!ret)
		return NULL;
	Py_INCREF(container_of(trace->prog, Program, prog));
	ret->trace = trace;
	return (PyObject *)ret;
}

static void StackTrace_dealloc(StackTrace *self)
{
	PyObject_GC_UnTrack(self);
	if (self->trace) {
		struct drgn_program *prog = self->trace->prog;
		drgn_stack_trace_destroy(self->trace);
		Py_DECREF(container_of(prog, Program, prog));
	}
	Py_TYPE(self)->tp_free((PyObject *)self);
}

static int StackTrace_traverse(StackTrace *self, visitproc visit, void *arg)
{
	if (self->trace)
		Py_VISIT(container_of(self->trace->prog, Program, prog));
	return 0;
}

static Program *StackTrace_get_prog(StackTrace *self, void *arg)
{
	Program *prog = container_of(drgn_stack_trace_program(self->trace),
				     Program, prog);
	Py_INCREF(prog);
	return prog;
}

static PyObject *StackTrace_str(StackTrace *self)
{
	struct drgn_error *err;
	_cleanup_free_ char *str = NULL;
	err = drgn_format_stack_trace(self->trace, &str);
	if (err)
		return set_drgn_error(err);
	return PyUnicode_FromString(str);
}

static Py_ssize_t StackTrace_length(StackTrace *self)
{
	return drgn_stack_trace_num_frames(self->trace);
}

static StackFrame *StackTrace_item(StackTrace *self, Py_ssize_t i)
{
	if (i < 0 || i >= drgn_stack_trace_num_frames(self->trace)) {
		PyErr_SetString(PyExc_IndexError,
				"stack frame index out of range");
		return NULL;
	}
	StackFrame *ret = call_tp_alloc(StackFrame);
	if (!ret)
		return NULL;
	ret->i = i;
	ret->trace = self;
	Py_INCREF(self);
	return ret;
}

static PyMethodDef StackTrace_methods[] = {
	{"_repr_pretty_", (PyCFunction)repr_pretty_from_str,
	 METH_VARARGS | METH_KEYWORDS},
	{},
};

static PySequenceMethods StackTrace_as_sequence = {
	.sq_length = (lenfunc)StackTrace_length,
	.sq_item = (ssizeargfunc)StackTrace_item,
};

static PyGetSetDef StackTrace_getset[] = {
	{"prog", (getter)StackTrace_get_prog, NULL, drgn_StackTrace_prog_DOC},
	{},
};

PyTypeObject StackTrace_type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "_drgn.StackTrace",
	.tp_basicsize = sizeof(StackTrace),
	.tp_dealloc = (destructor)StackTrace_dealloc,
	.tp_as_sequence = &StackTrace_as_sequence,
	.tp_str = (reprfunc)StackTrace_str,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
	.tp_doc = drgn_StackTrace_DOC,
	.tp_traverse = (traverseproc)StackTrace_traverse,
	.tp_methods = StackTrace_methods,
	.tp_getset = StackTrace_getset,
};

static void StackFrame_dealloc(StackFrame *self)
{
	PyObject_GC_UnTrack(self);
	Py_XDECREF(self->trace);
	Py_TYPE(self)->tp_free((PyObject *)self);
}

static int StackFrame_traverse(StackFrame *self, visitproc visit, void *arg)
{
	Py_VISIT(self->trace);
	return 0;
}

static PyObject *StackFrame_str(StackFrame *self)
{
	struct drgn_error *err;
	_cleanup_free_ char *str = NULL;
	err = drgn_format_stack_frame(self->trace->trace, self->i, &str);
	if (err)
		return set_drgn_error(err);
	return PyUnicode_FromString(str);
}

static PyObject *StackFrame_locals(StackFrame *self)
{
	struct drgn_error *err;
	const char **names;
	size_t count;
	err = drgn_stack_frame_locals(self->trace->trace, self->i, &names,
				      &count);
	if (err)
		return set_drgn_error(err);

	_cleanup_pydecref_ PyObject *list = PyList_New(count);
	if (!list) {
		drgn_stack_frame_locals_destroy(names, count);
		return NULL;
	}
	for (size_t i = 0; i < count; i++) {
		PyObject *string = PyUnicode_FromString(names[i]);
		if (!string) {
			drgn_stack_frame_locals_destroy(names, count);
			return NULL;
		}
		PyList_SET_ITEM(list, i, string);
	}
	drgn_stack_frame_locals_destroy(names, count);
	return_ptr(list);
}

static DrgnObject *StackFrame_subscript(StackFrame *self, PyObject *key)
{
	struct drgn_error *err;
	Program *prog = container_of(self->trace->trace->prog, Program, prog);
	if (!PyUnicode_Check(key)) {
		PyErr_SetObject(PyExc_KeyError, key);
		return NULL;
	}
	const char *name = PyUnicode_AsUTF8(key);
	if (!name)
		return NULL;
	_cleanup_pydecref_ DrgnObject *ret = DrgnObject_alloc(prog);
	if (!ret)
		return NULL;
	bool clear = set_drgn_in_python();
	err = drgn_stack_frame_find_object(self->trace->trace, self->i, name,
					   &ret->obj);
	if (clear)
		clear_drgn_in_python();
	if (err) {
		if (err->code == DRGN_ERROR_LOOKUP) {
			drgn_error_destroy(err);
			PyErr_SetObject(PyExc_KeyError, key);
		} else {
			set_drgn_error(err);
		}
		return NULL;
	}
	return_ptr(ret);
}

static int StackFrame_contains(StackFrame *self, PyObject *key)
{
	struct drgn_error *err;
	if (!PyUnicode_Check(key)) {
		PyErr_SetObject(PyExc_KeyError, key);
		return -1;
	}
	const char *name = PyUnicode_AsUTF8(key);
	if (!name)
		return -1;
	DRGN_OBJECT(tmp, self->trace->trace->prog);
	err = drgn_stack_frame_find_object(self->trace->trace, self->i, name,
					   &tmp);
	if (!err) {
		return 1;
	} else if (err->code == DRGN_ERROR_LOOKUP) {
		drgn_error_destroy(err);
		return 0;
	} else {
		return -1;
	}
}

static PyObject *StackFrame_source_name(StackFrame *self)
{
	_cleanup_free_ char *str = NULL;
	struct drgn_error *err =
		drgn_stack_frame_source_name(self->trace->trace, self->i,
					     &str);
	if (err)
		return set_drgn_error(err);
	if (!str)
		Py_RETURN_NONE;
	return PyUnicode_FromString(str);
}

static PyObject *StackFrame_source(StackFrame *self)
{
	int line;
	int column;
	const char *filename = drgn_stack_frame_source(self->trace->trace,
						       self->i, &line, &column);
	if (!filename) {
		PyErr_SetString(PyExc_LookupError,
				"source code location not available");
		return NULL;
	}

	static PyMethodDef meth = {
		.ml_name = "name",
		.ml_meth = (PyCFunction)StackFrame_source_name,
		.ml_flags = METH_NOARGS,
	};
	return PyObject_CallFunction(SourceLocation_type, "siiN", filename,
				     line, column,
				     PyCFunction_New(&meth, (PyObject *)self));
}

static PyObject *StackFrame_symbol(StackFrame *self)
{
	struct drgn_error *err;
	Program *prog = container_of(self->trace->trace->prog, Program, prog);
	struct drgn_symbol *sym;
	err = drgn_stack_frame_symbol(self->trace->trace, self->i, &sym);
	if (err)
		return set_drgn_error(err);
	PyObject *ret = Symbol_wrap(sym, (PyObject *)prog);
	if (!ret) {
		drgn_symbol_destroy(sym);
		return NULL;
	}
	return ret;
}

static PyObject *StackFrame_register(StackFrame *self, PyObject *arg)
{
	const char *name = PyUnicode_AsUTF8(arg);
	if (!name)
		return NULL;
	const struct drgn_platform *platform =
		drgn_program_platform(self->trace->trace->prog);
	const struct drgn_register *reg =
		drgn_platform_register_by_name(platform, name);
	if (!reg) {
		return PyErr_Format(PyExc_ValueError,
				    "unknown register %R", arg);
	}
	uint64_t value;
	if (!drgn_stack_frame_register(self->trace->trace, self->i, reg,
				       &value)) {
		PyErr_SetString(PyExc_LookupError,
				"register value is not known");
		return NULL;
	}
	return PyLong_FromUInt64(value);
}

static PyObject *StackFrame_registers(StackFrame *self)
{
	_cleanup_pydecref_ PyObject *dict = PyDict_New();
	if (!dict)
		return NULL;
	const struct drgn_platform *platform =
		drgn_program_platform(self->trace->trace->prog);
	size_t num_registers = drgn_platform_num_registers(platform);
	for (size_t i = 0; i < num_registers; i++) {
		const struct drgn_register *reg =
			drgn_platform_register(platform, i);
		uint64_t value;
		if (!drgn_stack_frame_register(self->trace->trace, self->i, reg,
					       &value))
			continue;
		_cleanup_pydecref_ PyObject *value_obj =
			PyLong_FromUInt64(value);
		if (!value_obj)
			return NULL;
		size_t num_names;
		const char * const *names = drgn_register_names(reg,
								&num_names);
		for (size_t j = 0; j < num_names; j++) {
			if (PyDict_SetItemString(dict, names[j], value_obj))
				return NULL;
		}
	}
	return_ptr(dict);
}

static PyObject *StackFrame_get_name(StackFrame *self, void *arg)
{
	_cleanup_free_ char *name = NULL;
	struct drgn_error *err = drgn_stack_frame_name(self->trace->trace,
						       self->i, &name);
	if (err)
		return set_drgn_error(err);
	return PyUnicode_FromString(name);
}

static PyObject *StackFrame_get_function_name(StackFrame *self, void *arg)
{
	const char *function_name =
		drgn_stack_frame_function_name(self->trace->trace, self->i);
	if (function_name)
		return PyUnicode_FromString(function_name);
	else
		Py_RETURN_NONE;
}

static PyObject *StackFrame_get_is_inline(StackFrame *self, void *arg)
{
	Py_RETURN_BOOL(drgn_stack_frame_is_inline(self->trace->trace, self->i));
}

static PyObject *StackFrame_get_interrupted(StackFrame *self, void *arg)
{
	Py_RETURN_BOOL(drgn_stack_frame_interrupted(self->trace->trace,
						    self->i));
}

static PyObject *StackFrame_get_pc(StackFrame *self, void *arg)
{
	uint64_t pc;
	if (drgn_stack_frame_pc(self->trace->trace, self->i, &pc)) {
		return PyLong_FromUInt64(pc);
	} else {
		PyErr_SetString(PyExc_LookupError,
				"program counter is not known");
		return NULL;
	}
}

static PyObject *StackFrame_get_sp(StackFrame *self, void *arg)
{
	uint64_t sp;
	if (drgn_stack_frame_sp(self->trace->trace, self->i, &sp)) {
		return PyLong_FromUInt64(sp);
	} else {
		PyErr_SetString(PyExc_LookupError,
				"stack pointer is not known");
		return NULL;
	}
}

static PyMethodDef StackFrame_methods[] = {
	{"__getitem__", (PyCFunction)StackFrame_subscript,
	 METH_O | METH_COEXIST, drgn_StackFrame___getitem___DOC},
	{"__contains__", (PyCFunction)StackFrame_contains,
	 METH_O | METH_COEXIST, drgn_StackFrame___contains___DOC},
	{"locals", (PyCFunction)StackFrame_locals,
	 METH_NOARGS, drgn_StackFrame_locals_DOC},
	{"source", (PyCFunction)StackFrame_source, METH_NOARGS,
	 drgn_StackFrame_source_DOC},
	{"symbol", (PyCFunction)StackFrame_symbol, METH_NOARGS,
	 drgn_StackFrame_symbol_DOC},
	{"register", (PyCFunction)StackFrame_register,
	 METH_O, drgn_StackFrame_register_DOC},
	{"registers", (PyCFunction)StackFrame_registers,
	 METH_NOARGS, drgn_StackFrame_registers_DOC},
	{"_repr_pretty_", (PyCFunction)repr_pretty_from_str,
	 METH_VARARGS | METH_KEYWORDS},
	{},
};

static PyGetSetDef StackFrame_getset[] = {
	{"name", (getter)StackFrame_get_name, NULL, drgn_StackFrame_name_DOC},
	{"function_name", (getter)StackFrame_get_function_name, NULL,
	 drgn_StackFrame_function_name_DOC},
	{"is_inline", (getter)StackFrame_get_is_inline, NULL,
	 drgn_StackFrame_is_inline_DOC},
	{"interrupted", (getter)StackFrame_get_interrupted, NULL,
	 drgn_StackFrame_interrupted_DOC},
	{"pc", (getter)StackFrame_get_pc, NULL, drgn_StackFrame_pc_DOC},
	{"sp", (getter)StackFrame_get_sp, NULL, drgn_StackFrame_sp_DOC},
	{},
};

static PyMappingMethods StackFrame_as_mapping = {
	.mp_subscript = (binaryfunc)StackFrame_subscript,
};

static PySequenceMethods StackFrame_as_sequence = {
	.sq_contains = (objobjproc)StackFrame_contains,
};

PyTypeObject StackFrame_type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "_drgn.StackFrame",
	.tp_basicsize = sizeof(StackFrame),
	.tp_dealloc = (destructor)StackFrame_dealloc,
	.tp_as_sequence = &StackFrame_as_sequence,
	.tp_as_mapping = &StackFrame_as_mapping,
	.tp_str = (reprfunc)StackFrame_str,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
	.tp_doc = drgn_StackFrame_DOC,
	.tp_traverse = (traverseproc)StackFrame_traverse,
	.tp_methods = StackFrame_methods,
	.tp_getset = StackFrame_getset,
};
