package qrstr

/*
 * This file is to turn strings into unicode or html qr codes.
 * Author: sophuwu <sophie@sophuwu.com>
 * Feel free to use this code in any way you want.
 * The header will display the string above the qr code.
 */

import (
	"fmt"
	"github.com/boombuler/barcode/qr"
	"image"
	"image/color"
	"slices"
	"strings"
)

// utf8r aliases rune
type utf8r rune

// String returns the plain text or html representation of the rune
func (u utf8r) String(html bool) string {
	if html {
		return fmt.Sprintf("<td>&#x%x;</td>", u)
	}
	return string(u)
}

const blank rune = ' '
const upper rune = '▀'
const lower rune = '▄'
const whole rune = '█'

// pad returns a string with the given length
func pad(n int, r ...rune) string {
	if n == 0 {
		return ""
	}
	if n < 0 {
		n = 1
	}
	if len(r) == 0 {
		return strings.Repeat(string(whole), n)
	}
	return strings.Repeat(string(r[0]), n)
}

type runeCol []rune

func (c *runeCol) getRune(top, bot color.Color) rune {
	return (*c)[func() int {
		i := 0
		if top == color.Black {
			i |= 1
		}
		if bot == color.Black {
			i |= 2
		}
		return i
	}()]
}

func (c *runeCol) addRune(s *string, top, bot color.Color) {
	*s += string(c.getRune(top, bot))
}

var lightMode = runeCol{blank, upper, lower, whole}
var darkMode = runeCol{whole, lower, upper, blank}

// wrap wraps text around a newline, hard wrapping at the given width
// but trying to soft wrap if possible
func wrap(w int, s ...string) []string {
	var line = ""
	var lines, b []string
	var v string
	var i, j int
	w--
	for _, l := range s {
		if len(l) < w {
			lines = append(lines, l)
			continue
		}

		b = strings.Split(l, " ")
		for i, v = range b {
			if len(v) > w {
				for j = 0; j < len(v); j += w {
					if j+w < len(v) {
						lines = append(lines, v[j:j+w]+"-")
					} else {
						line = v[j:] + " "
					}
				}
				continue
			}
			if len(line)+len(v) < w {
				line += v + " "
			} else {
				lines = append(lines, strings.TrimSuffix(line, " "))
				line = ""
				continue
			}
			if i == len(b)-1 {
				lines = append(lines, strings.TrimSuffix(line, " "))
				line = ""
				continue
			}
		}
	}

	return slices.Clip(lines)
}

type Encoder struct {
	strFunc func(rc *runeCol, code *image.Image, headers *[]string) (string, error)
	rc      *runeCol
	errCorr ErrorCorrectionLevel
}

// Encode encodes data with configuration from NewEncoder into a qr code string.
// If headers are provided, they will be displayed above the qr code in the output.
func (q *Encoder) Encode(data string, headers ...string) (string, error) {
	strFunc := q.strFunc
	if strFunc == nil {
		return "", fmt.Errorf("encoder misconfigured, use NewEncoder when creating it")
	}
	var code image.Image
	var err error
	code, err = qr.Encode(data, qr.ErrorCorrectionLevel((*q).errCorr), qr.Auto)
	if err != nil {
		return "", err
	}
	return strFunc(q.rc, &code, &headers)
}

func text(rc *runeCol, code *image.Image, headers *[]string) (string, error) {
	if rc == nil || code == nil {
		return "", fmt.Errorf("encoder misconfigured, use NewEncoder when creating it")
	}
	var output = ""
	dx := (*code).Bounds().Dx()
	dy := (*code).Bounds().Dy()
	wr := rc.getRune(color.White, color.White)
	prefix := string(wr)
	suffix := string(wr) + "\n"

	hashead := headers != nil && len(*headers) > 0

	if hashead {
		output += fmt.Sprintln(string(whole) + pad(dx+2, upper) + string(whole))
		for _, v := range wrap(dx, *headers...) {
			v = v + pad(dx-len(v)+1, blank) + string(whole)
			v = string(whole) + string(blank) + v
			output += v + "\n"
		}

		output += string(whole) + pad(dx+2, lower) + string(whole) + "\n" + string(whole) + pad(dx+2, wr) + string(whole) + "\n"
		prefix = string(whole) + string(wr)
		suffix = string(wr) + string(whole) + "\n"
	} else {
		output += pad(dx+2, wr) + "\n"
	}

	output += prefix
	prefix = suffix + prefix

	var y, x int
	for y = 0; y < dy-dy%2; y += 2 {
		for x = 0; x < dx; x++ {
			rc.addRune(&output, (*code).At(x, y), (*code).At(x, y+1))
		}
		output += prefix
	}
	if dy%2 == 1 {
		for x = 0; x < dx; x++ {
			rc.addRune(&output, (*code).At(x, y), color.White)
		}
		output += suffix
	} else {
		output = strings.TrimSuffix(output, prefix) + suffix
	}

	if hashead {
		output += pad(dx+4, wr) + "\n"
	} else {
		output += pad(dx+2, wr) + "\n"
	}

	return output, nil
}

const css = `<style>
.qrstr-white {
	background-color: white;
	color: white;
	border-color: white;
	padding: 0.5em;
}
.qrstr-black {
	background-color: black;
	color: black;
	border-color: black;
	padding: 0.5em;
}
.qrstr-code , .qrstr-code * {
	border: 0;
	font-family: monospace;
	padding: 0;
	margin: 0;
	font-size: 10%;
	letter-spacing: 0;
	border-spacing: 0;
	border-collapse: collapse;
}
</style>
`

func html(rc *runeCol, code *image.Image, headers *[]string) (string, error) {
	var output = "<div style=\"width: min-content;background: white; color: black;  padding: 1lh;\">\n" + css
	if code == nil {
		return "", fmt.Errorf("encoder misconfigured, use NewEncoder when creating it")
	}
	hashead := headers != nil && len(*headers) > 0
	if hashead {
		for _, v := range *headers {
			output += "<p>" + v + "</p>\n"
		}
		output += "<hr>\n"
	}
	dx := (*code).Bounds().Dx()
	dy := (*code).Bounds().Dy()
	output += "<table class\"qrstr-code\" style=\"border-collapse: collapse;\">\n"
	for y := 0; y < dy; y++ {
		output += "<tr>\n"
		for x := 0; x < dx; x++ {
			if (*code).At(x, y) == color.Black {
				output += "<td class=\"qrstr-black\"></td>\n"
			} else {
				output += "<td class=\"qrstr-white\"></td>\n"
			}
		}
		output += "</tr>\n"
	}
	output += "</table></div>\n"
	return output, nil
}

type EncoderType int
type ErrorCorrectionLevel qr.ErrorCorrectionLevel

const (
	// TextDarkMode makes qr codes for printing on dark backgrounds with white text,
	// like a terminal or a screen with dark/night mode enabled.
	// This mode is not recommended for terminals, use TerminalMode instead.
	// MUST BE PRINTED/DISPLAYED USING A MONOSPACE FONT.
	TextDarkMode EncoderType = 0
	// TextLightMode makes qr codes for printing on light backgrounds with black text,
	// like white paper or a screen with light mode.
	// This mode is not recommended for terminals, use TerminalMode instead.
	// MUST BE PRINTED/DISPLAYED USING A MONOSPACE FONT.
	TextLightMode EncoderType = 1
	// HTMLMode makes qr codes for embedding in HTML documents or web pages.
	// Colours are set automatically with this mode.
	// Generates a table using HTML tags, does not require a monospace font.
	HTMLMode EncoderType = 2
	// TerminalMode makes qr codes for printing on xterm terminals with auto color.
	// Colours are set automatically with this mode.
	// MUST BE PRINTED/DISPLAYED USING A MONOSPACE FONT.
	TerminalMode EncoderType = 3

	// ErrorCorrection7Percent indicates 7% of lost data can be recovered, makes the qr code smaller
	ErrorCorrection7Percent ErrorCorrectionLevel = 0
	// ErrorCorrection15Percent indicates 15% of lost data can be recovered, default
	ErrorCorrection15Percent ErrorCorrectionLevel = 1
	// ErrorCorrection25Percent indicates 25% of lost data can be recovered, makes the qr code bigger
	ErrorCorrection25Percent ErrorCorrectionLevel = 2
	// ErrorCorrection30Percent indicates 30% of lost data can be recovered, makes the qr code very big
	ErrorCorrection30Percent ErrorCorrectionLevel = 3
)

// NewEncoder returns qr encoder with the given type and error correction level.
// The encoder type determines the output format of the qr code.
// The error correction level determines the amount of data that can be recovered from the qr code.
// The encoder type must be one of the following: TextDarkMode, TextLightMode, HTMLMode
// The error correction level must be one of the following: ErrorCorrection7Percent, ErrorCorrection15Percent, ErrorCorrection25Percent, ErrorCorrection30Percent
func NewEncoder(encoderType EncoderType, errorCorrectionLevel ErrorCorrectionLevel) (*Encoder, error) {
	var q Encoder
	switch encoderType {
	case TextDarkMode:
		q.rc = &darkMode
		q.strFunc = text
		break
	case TextLightMode:
		q.rc = &lightMode
		q.strFunc = text
		break
	case HTMLMode:
		q.strFunc = html
		break
	case TerminalMode:
		q.rc = &darkMode
		q.strFunc = func(rc *runeCol, code *image.Image, headers *[]string) (string, error) {
			s, e := text(rc, code, headers)
			if e != nil {
				return "", e
			}
			front := "\033[40;97m"
			back := "\033[0m\n"
			s = strings.ReplaceAll(s, "\n", back+front)
			return front + strings.TrimSuffix(s, front), nil
		}
		break
	default:
		return nil, fmt.Errorf("invalid encoder type: %d", encoderType)
	}
	if errorCorrectionLevel < 0 || errorCorrectionLevel > 3 {
		return nil, fmt.Errorf("invalid error correction level: %d", errorCorrectionLevel)
	}
	q.errCorr = errorCorrectionLevel
	return &q, nil
}