package pdfhelper

import (
	"fmt"
	"strings"

	"git.to-net.rs/marko.tikvic/gofpdf"
)

// Block ...
const (
	CENTER   = "C"
	LEFT     = "L"
	RIGHT    = "R"
	TOP      = "T"
	BOTTOM   = "B"
	FULL     = "1"
	NOBORDER = ""
)

const (
	CONTINUE = 0
	NEWLINE  = 1
	BELLOW   = 2
)

const (
	cyrillicEncoding = "cp1251"
	latinEncoding    = "cp1250"
)

// Helper ...
type Helper struct {
	*gofpdf.Fpdf
	translators map[string]func(string) string
}

// New ...
func New(ori, unit, size string) *Helper {
	helper := &Helper{
		Fpdf: gofpdf.New(ori, unit, size, ""),
	}

	return helper
}

func (pdf *Helper) LoadTranslators() {
	pdf.translators = make(map[string]func(string) string)
	pdf.translators[latinEncoding] = pdf.UnicodeTranslatorFromDescriptor(latinEncoding)
	pdf.translators[cyrillicEncoding] = pdf.UnicodeTranslatorFromDescriptor(cyrillicEncoding)
}

// InsertTab ...
func (pdf *Helper) InsertTab(count int, w, h float64) {
	for i := 0; i < count; i++ {
		pdf.Cell(w, h, "")
	}
}

// CellWithBox ...
func (pdf *Helper) CellWithBox(w, h float64, text, align string) {
	//pdf.drawCellMargins(w, h)
	//pdf.Cell(w, h, text)
	pdf.CellFormat(w, h, pdf.ToUTF8(text), FULL, CONTINUE, align, false, 0, "")
}

func (pdf *Helper) CellWithMargins(w, h float64, text, align string, index, of int) {
	len := of - 1
	border := ""

	// if top cell
	if index == 0 {
		border += "T"
	}

	border += "LR" // always draw these

	// if bottom cell
	if index == len {
		border += "B"
	}

	pdf.CellFormat(w, h, pdf.ToUTF8(text), border, CONTINUE, align, false, 0, "")
}

// MultiRowCellWithBox ...
func (pdf *Helper) MultiRowCellWithBox(w, h float64, text []string, align string) {
	pdf.drawCellMargins(w, h*float64(len(text)))
	for i := range text {
		pdf.CellFormat(w, h, pdf.ToUTF8(text[i]), "", BELLOW, align, false, 0, "")
	}
}

// CellFormat(w, h, text, borders, newLine, fill)

type FormatedCell struct {
	W, H            float64
	Text            string
	Font, FontStyle string
	FontSize        float64
	Border          string
	Alignment       string
}

func (pdf *Helper) FCell(x, y float64, c FormatedCell) {
	pdf.SetXY(x, y)
	pdf.SetFont(c.Font, c.FontStyle, c.FontSize)
	pdf.CellFormat(c.W, c.H, pdf.ToUTF8(c.Text), c.Border, BELLOW, c.Alignment, false, 0, "")
}

func (pdf *Helper) Column(x, y float64, cells []FormatedCell) {
	pdf.SetXY(x, y)
	for _, c := range cells {
		pdf.SetFont(c.Font, c.FontStyle, c.FontSize)
		pdf.CellFormat(c.W, c.H, pdf.ToUTF8(c.Text), c.Border, BELLOW, c.Alignment, false, 0, "")
		//pdf.CellFormat(c.w, c.h, c.text, c.border, BELLOW, align, false, 0, "")
	}
}

// NewLine ...
func (pdf *Helper) NewLine(h float64) {
	pdf.Ln(h)
}

// WriteColumns ...
func (pdf *Helper) WriteColumns(align string, cols []PDFCell) {
	for _, c := range cols {
		pdf.CellFormat(c.width, c.height, pdf.ToUTF8(c.data), "", CONTINUE, align, false, 0, "")
	}
}

func (pdf *Helper) Row(x, y float64, cells []FormatedCell) {
	pdf.SetXY(x, y)
	for _, c := range cells {
		pdf.SetFont(c.Font, c.FontStyle, c.FontSize)
		pdf.CellFormat(c.W, c.H, pdf.ToUTF8(c.Text), c.Border, CONTINUE, c.Alignment, false, 0, "")
	}
}

const threeDots = "\u2056\u2056\u2056"

// WriteColumnsWithAlignment ...
func (pdf *Helper) WriteColumnsWithAlignment(cols []PDFCellAligned) {
	for _, c := range cols {
		lines := pdf.SplitText(c.data, c.width)
		if len(lines) == 1 {
			pdf.CellFormat(c.width, c.height, pdf.ToUTF8(lines[0]), "", CONTINUE, c.alignment, false, 0, "")
		} else {
			pdf.CellFormat(c.width, c.height, pdf.ToUTF8(lines[0]+threeDots), "", CONTINUE, c.alignment, false, 0, "")
		}
	}

}

func (pdf *Helper) LimitText(text, limiter string, maxWidth float64) string {
	parts := pdf.Fpdf.SplitText(text, maxWidth)
	if len(parts) > 1 {
		return parts[0] + limiter
	}

	return text
}

// InsertImage ...
func (pdf *Helper) InsertImage(img string, x, y, w, h float64) {
	imgType := ""
	if parts := strings.Split(img, "."); len(parts) >= 2 {
		imgType = parts[len(parts)-1]
	}
	opt := gofpdf.ImageOptions{
		ImageType:             imgType,
		ReadDpi:               false,
		AllowNegativePosition: false,
	}
	autoBreak := false // if it's not false then you can't draw the image at an arbitrary height (y position)
	pdf.ImageOptions(img, x, y, w, h, autoBreak, opt, 0, "")
}

// PDFCell ...
type PDFCell struct {
	data          string
	height, width float64
}

// PDFCellAligned ...
type PDFCellAligned struct {
	alignment     string
	data          string
	height, width float64
}

func (pdf *Helper) TextLength(txt, family, style string, size float64) float64 {
	family, _, _, _ = pdf.setCorrectFontFamily(textEncoding(txt))
	return pdf.Fpdf.TextLength(txt, family, style, size)
}

func textEncoding(s string) string {
	encoding := latinEncoding
	runes := []rune(s)
	for _, r := range runes {
		if uint64(r) >= 0x0402 && uint64(r) <= 0x044f {
			encoding = cyrillicEncoding
			break
		}
	}
	return encoding
}

// ToUTF8 ...
func (pdf *Helper) ToUTF8(s string) string {
	encoding := textEncoding(s)
	pdf.setCorrectFontFamily(encoding)
	translator, ok := pdf.translators[encoding]
	if !ok {
		return ""
	}
	return translator(s)
}

func (pdf *Helper) setCorrectFontFamily(enc string) (family, style string, ptSize, unitSize float64) {
	family, style, ptSize, unitSize = pdf.GetFontInfo()
	if enc == cyrillicEncoding {
		if !strings.HasSuffix(family, "cyrillic") {
			family += "cyrillic"
		}
	} else {
		if strings.HasSuffix(family, "cyrillic") {
			family = strings.TrimSuffix(family, "cyrillic")
		}
	}
	pdf.SetFont(family, style, ptSize)
	return family, style, ptSize, unitSize
}

func (pdf *Helper) PageHasSpace(requiredHeight float64) bool {
	_, h := pdf.GetPageSize()
	_, _, _, bot := pdf.GetMargins()
	return (h - bot - pdf.GetY()) > requiredHeight
}

func (pdf *Helper) imageCenterOffset(w, h float64) (x, y float64) {
	pageW, pageH := pdf.GetPageSize()
	x = pageW/2.0 - w/2.0
	y = pageH/2.0 - h/2.0
	return x, y
}

// call before drawing the cell
func (pdf *Helper) drawCellMargins(cw, ch float64) {
	x0, y0 := pdf.GetX(), pdf.GetY()
	pdf.DrawBox(x0, y0, cw, ch)
}

// DrawBox ...
func (pdf Helper) DrawBox(x0, y0, w, h float64) {
	pdf.Line(x0, y0, x0+w, y0)
	pdf.Line(x0+w, y0, x0+w, y0+h)
	pdf.Line(x0+w, y0+h, x0, y0+h)
	pdf.Line(x0, y0+h, x0, y0)
}

// Strana %d/{TotalPages}
func (pdf *Helper) InsertPageNumber(x, y float64, format string) {
	num := fmt.Sprintf(format, pdf.PageNo())
	pdf.Column(x, y, []FormatedCell{{10, 1, num, "DejaVuSans", "", 8, NOBORDER, LEFT}})
}

func (pdf *Helper) SuperscriptText(x, y, cw, ch float64, text, script string) {
	family, style, size, sizeU := pdf.setCorrectFontFamily(textEncoding(text))

	pdf.FCell(x, y, FormatedCell{cw, ch, text, family, style, size, NOBORDER, LEFT})

	sx := x + pdf.TextLength(text, family, style, size)
	sy := y - sizeU*0.2
	pdf.FCell(sx, sy, FormatedCell{cw, ch, script, family, style, size - 2, NOBORDER, LEFT})
}