package transpile_python

import (
	"bytes"
	"strings"
	"testing"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	gomega_format "github.com/onsi/gomega/format"
)

func TestUtils(t *testing.T) {
	RegisterFailHandler(Fail)
	gomega_format.CharactersAroundMismatchToInclude = 20
	RunSpecs(t, "Go Translator to Python/Skidl")
}

var _ = Describe("Go Translator to Python/Skidl", func() {
	Describe("All", func() {
		It("Empty Package", func() {
			source := `package test`
			expected := ``
			Compare(source, expected)
		})

		It("Importing skidl", func() {
			source := `package test
				import (
					. "skidl"
				)
				`
			expected := `from skidl import *

main()
`
			Compare(source, expected)
		})

		It("Importing skidl and FreeCAD", func() {
			source := `package test
				import (
					. "skidl"
					. "FreeCAD"
				)
				`
			expected := `from skidl import *
from FreeCAD import *

main()
`
			Compare(source, expected)
		})

		It("Importing inline", func() {
			source := `package test
				import (
					"skidl"
					"FreeCAD"
				)
				`
			expected := `import skidl
import FreeCAD

main()
`
			Compare(source, expected)
		})

		It("Variables declaration", func() {
			source := `package test
				import . "skidl"

				var (
					a = 1
					b = 2
					c = 3
					d = a + b + c / 2
					t = true
					f = false
				)
				`
			expected := `from skidl import *

a = 1
b = 2
c = 3
d = a + b + c / 2
t = True
f = False

main()
`
			Compare(source, expected)
		})

		It("Simple bool assignment", func() {
			source := `package test
				import . "skidl"

				func main() {
					t := true
					o = true
				}
				`
			expected := `from skidl import *

def main():
	t = True
	o = True
main()
`
			Compare(source, expected)
		})

		It("Empty Array assignment", func() {
			source := `package test
				import . "skidl"

				func main() {
					a := []any{}
					a = []any{}
				}
				`
			expected := `from skidl import *

def main():
	a = []
	a = []
main()
`
			Compare(source, expected)
		})

		It("Inited array assignment", func() {
			source := `package test
				import . "skidl"

				func main() {
					a := []any{1, 2, x}
				}
				`
			expected := `from skidl import *

def main():
	a = (1,2,x)
main()
`
			Compare(source, expected)
		})

		It("Array append", func() {
			source := `package test
				import . "skidl"

				func main() {
					append(a, 1)
				}
				`
			expected := `from skidl import *

def main():
	a.append(1)
main()
`
			Compare(source, expected)
		})

		It("Deep property assign", func() {
			source := `package test
				import . "skidl"

				func main() {
					a.b.c = 1
				}
				`
			expected := `from skidl import *

def main():
	a.b.c = 1
main()
`
			Compare(source, expected)
		})

		It("Function Declaration", func() {
			source := `package test
				import . "skidl"

				func main() {}
				`
			expected := `from skidl import *

def main():
	None
main()
`
			Compare(source, expected)
		})

		It("Func call", func() {
			source := `package test
				import . "skidl"

				func main() {
					generate_netlist()
				}
				`
			expected := `from skidl import *

def main():
	generate_netlist()
main()
`
			Compare(source, expected)
		})

		It("Func return", func() {
			source := `package test
				import . "skidl"

				func myfunc(p1, p2 any) any {
					return 5
				}
				func main() {
					v := myfunc(1, 2)
				}
				`
			expected := `from skidl import *

def myfunc(p1,p2):
	return 5
def main():
	v = myfunc(1,2)
main()
`
			Compare(source, expected)
		})

		It("Net Declaration", func() {
			source := `package test
				import . "skidl"

				func main() {
					vin := Net("3.3v")
				}
				`
			expected := `from skidl import *

def main():
	vin = Net("3.3v")
main()
`
			Compare(source, expected)
		})

		It("Nets Declaration", func() {
			source := `package test
				import . "skidl"

				func main() {
					vin := Net("3.3v")
					gnd := Net("GND")
				}
				`
			expected := `from skidl import *

def main():
	vin = Net("3.3v")
	gnd = Net("GND")
main()
`
			Compare(source, expected)
		})

		It("Part Declaration", func() {
			source := `package test
				import . "skidl"

				func main() {
					ESP32 := Part("RF_Module", "ESP32-WROOM-32", TEMPLATE, footprint == "RF_Module:ESP32-WROOM-32")
				}
				`
			expected := `from skidl import *

def main():
	ESP32 = Part("RF_Module","ESP32-WROOM-32",TEMPLATE,footprint="RF_Module:ESP32-WROOM-32")
main()
`
			Compare(source, expected)
		})

		It("Parts Declaration", func() {
			source := `package test
				import . "skidl"

				func main() {
					ESP32 := Part("RF_Module", "ESP32-WROOM-32", TEMPLATE, footprint == "RF_Module:ESP32-WROOM-32")
					Klema := Part("Connector_Generic_MountingPin", "Conn_01x01_MountingPin", TEMPLATE, footprint == "TestPoint_Pad_2.0x2.0mm")
				}
				`
			expected := `from skidl import *

def main():
	ESP32 = Part("RF_Module","ESP32-WROOM-32",TEMPLATE,footprint="RF_Module:ESP32-WROOM-32")
	Klema = Part("Connector_Generic_MountingPin","Conn_01x01_MountingPin",TEMPLATE,footprint="TestPoint_Pad_2.0x2.0mm")
main()
`
			Compare(source, expected)
		})

		It("Values Declaration", func() {
			source := `package test
				import . "skidl"

				func main() {
					esp32 := ESP32(value == "ESP32")
					k_vin, k_gnd := Klema(2)
				}
				`
			expected := `from skidl import *

def main():
	esp32 = ESP32(value="ESP32")
	k_vin,k_gnd = Klema(2)
main()
`
			Compare(source, expected)
		})

		It("Values with params Declaration", func() {
			source := `package test
				import . "skidl"

				func main() {
				    tr_tok_verh := tr_npn(value == "tr Tok verh NPN")
				}
				`
			expected := `from skidl import *

def main():
    tr_tok_verh = tr_npn(value="tr Tok verh NPN")
main()
`
			Compare(source, expected)
		})

		It("Assignments += by name ", func() {
			source := `package test
				import . "skidl"

				func main() {
				    esp32["GND"] += gnd
				    esp32["VDD"] += vin
				}
				`
			expected := `from skidl import *

def main():
    esp32["GND"] += gnd
    esp32["VDD"] += vin
main()
`
			Compare(source, expected)
		})

		It("Assignments += by index", func() {
			source := `package test
				import . "skidl"

				func main() {
				    esp32[1] += gnd
				    vin += r_fb[1]
				    tr1[1] += tr2[2]
				}
				`
			expected := `from skidl import *

def main():
    esp32[1] += gnd
    vin += r_fb[1]
	tr1[1] += tr2[2]
main()
`
			Compare(source, expected)
		})

		XIt("Assignments += by index of function call", func() {
			source := `package test
				import . "skidl"

				func main() {
					vkl_iface = vkl_iface_part(1)[0]
				}
				`
			expected := `from skidl import *

def main():
	vkl_iface = vkl_iface_part(1)[0]
main()
`
			Compare(source, expected)
		})

		It("Assignments &", func() {
			source := `package test
				import . "skidl"

				func main() {
				    tr_vkl["G"] & vkl
				    tr_vkl["G"] & tr2["S"]
				    tr_vkl & tr2["S"]
				}
				`
			expected := `from skidl import *

def main():
    tr_vkl["G"] & vkl
	tr_vkl["G"] & tr2["S"]
	tr_vkl & tr2["S"]
main()
`
			Compare(source, expected)
		})

		It("Value Assignment", func() {
			source := `package test
				import . "skidl"

				func main() {
				    vkl_iface.value = "k vkl"
				    vkl_iface.value = 19
				    vkl_iface.value = 19 / 3
				    vkl_iface.value = 19 * 2
				}
				`
			expected := `from skidl import *

def main():
	vkl_iface.value = "k vkl"
	vkl_iface.value = 19
	vkl_iface.value = 19 / 3
	vkl_iface.value = 19 * 2
main()
`
			Compare(source, expected)
		})

		It("Condition", func() {
			source := `package test
				import . "skidl"

				func main() {
					if a > 2 {
						x = 1
						y = 5
					} else {
						x = 6
						y = 9
					}
				}
				`
			expected := `from skidl import *

def main():
	if a > 2:
		x = 1
		y = 5
	else:
		x = 6
		y = 9
main()
`
			Compare(source, expected)
		})

		It("Condition complex", func() {
			source := `package test
				import . "skidl"

				func main() {
					if a > 2 {
						x = 1
						y = 5
						if b > 5 {
							x = 6
							y = 9
						} else {
							x = 15
						}
					} else {
						x = 18
					}
				}
				`
			expected := `from skidl import *

def main():
	if a > 2:
		x = 1
		y = 5
		if b > 5:
			x = 6
			y = 9
		else:
			x = 15
	else:
		x = 18
main()
`
			Compare(source, expected)
		})

		It("For with range", func() {
			source := `package test
				import . "skidl"

				func main() {
					for v := range list {
						call(v)
					}
				}
				`
			expected := `from skidl import *

def main():
	for v in list:
		call(v)
main()
`
			Compare(source, expected)
		})

		It("Function decl/call", func() {
			source := `package test
				import . "skidl"

				func vdiv(inp, outp, param string) {
					r1 := r(value == 1000)
					r2 := r(value == param)
				    inp & r1
				    r1 & outp
				    outp & r2
				    r2 & gnd
				}

				func main() {
					v := vdiv(inp, outp, "500")
				}
				`
			expected := `from skidl import *

def vdiv(inp,outp,param):
	r1 = r(value=1000)
	r2 = r(value=param)
    inp & r1
    r1 & outp
    outp & r2
    r2 & gnd
def main():
	v = vdiv(inp,outp,"500")
main()
`
			Compare(source, expected)
		})

		It("Subcircuit function decorator", func() {
			source := `package test
				import . "skidl"

				//@subcircuit
				func vdiv(inp, outp, param string) {
					r1 := r(value == 1000)
					r2 := r(value == param)
				    inp & r1
				    r1 & outp
				    outp & r2
				    r2 & gnd
				}

				func main() {
					v := vdiv(inp, outp, "500")
				}
				`
			expected := `from skidl import *

@subcircuit
def vdiv(inp,outp,param):
	r1 = r(value=1000)
	r2 = r(value=param)
    inp & r1
    r1 & outp
    outp & r2
    r2 & gnd
def main():
	v = vdiv(inp,outp,"500")
main()
`
			Compare(source, expected)
		})

		It("Package function decorator", func() {
			source := `package test
				import . "skidl"

				//@package
				func vdiv(inp, outp, param string) {
					r1 := r(value == 1000)
					r2 := r(value == param)
				    inp & r1
				    r1 & outp
				    outp & r2
				    r2 & gnd
				}

				func main() {
					v := vdiv(inp, outp, "500")
				}
				`
			expected := `from skidl import *

@package
def vdiv(inp,outp,param):
	r1 = r(value=1000)
	r2 = r(value=param)
	inp & r1
	r1 & outp
	outp & r2
	r2 & gnd
def main():
	v = vdiv(inp,outp,"500")
main()
`
			Compare(source, expected)
		})

		It("Interfaces", func() {
			source := `package test
				import . "skidl"

				//@subcircuit
				func mem_module(intfc any) {
					ram := Part("Memory_RAM", "AS6C1616")
					ram["A[0:19]"] += intfc.addr
					ram["DQ[0:15]"] += intfc.data
					ram["WE#"] += intfc.wr
					ram["OE#"] += intfc["rd"]
				}

				func main() {
					rd := Net("MEM_RD#")
					wr := Net("MEM_WR#")
					addr := Bus("MEM_ADDR", 20)
					data := Bus("MEM_DATA", 16)
					mem_intfc = Interface(rd == rd, wr == wr, addr == addr, data == data)
					mem_module(mem_intfc)
					uc_module(clk, mem_intfc, io_intfc)
				}
				`
			expected := `from skidl import *

@subcircuit
def mem_module(intfc):
	ram = Part("Memory_RAM","AS6C1616")
	ram["A[0:19]"] += intfc.addr
	ram["DQ[0:15]"] += intfc.data
	ram["WE#"] += intfc.wr
	ram["OE#"] += intfc["rd"]
def main():
	rd = Net("MEM_RD#")
	wr = Net("MEM_WR#")
	addr = Bus("MEM_ADDR",20)
	data = Bus("MEM_DATA",16)
	mem_intfc = Interface(rd=rd,wr=wr,addr=addr,data=data)
	mem_module(mem_intfc)
	uc_module(clk,mem_intfc,io_intfc)
main()
`
			Compare(source, expected)
		})
	})
})

func Compare(source, expected string) {
	var in, out bytes.Buffer
	in.WriteString(source)
	service := NewService(&in, &out)
	err := service.Start()
	got := out.String()
	tgot, texpected := Trim(got), Trim(expected)
	// spew.Dump(tgot)
	ExpectWithOffset(1, err).NotTo(HaveOccurred())
	ExpectWithOffset(1, tgot).To(Be(texpected))
}

func Trim(s string) string {
	s = strings.Replace(s, "\t", "    ", -1)
	return s
}

func NDescribe(s string, i func()) int { return 0 }
func NIt(s string, i func()) int       { return 0 }

var Be = Equal

func NoErr(err error) {
	ExpectWithOffset(1, err).NotTo(HaveOccurred())
}

var Ok = NoErr