package main

import (
	"os"

	pdf "github.com/stephenafamo/goldmark-pdf"
	"github.com/yuin/goldmark"
	"github.com/yuin/goldmark/extension"
	"github.com/yuin/goldmark/parser"
)

var markdown []byte = []byte(`
# Hello

- item 1
- item 2

# Goodbye
`)

func main() {
	file, err := os.Create("/tmp/output.pdf")
	if err != nil {
		panic(err)
	}

	md := goldmark.New(
		goldmark.WithExtensions(extension.GFM),
		goldmark.WithRenderer(
			pdf.New(),
		),
		goldmark.WithParserOptions(
			parser.WithAutoHeadingID(),
		),
	)

	if err := md.Convert(markdown, file); err != nil {
		panic(err)
	}
}

panic: interface conversion: ast.Node is *ast.String, not *ast.Text

goroutine 1 [running]:
github.com/stephenafamo/goldmark-pdf.(*nodeRederFuncs).renderText(0xc0002cc7ec?, 0xd2f3a0?, {0xc0003c4000?, 0x0?, 0x0?}, {0xd3dde0?, 0xc0000df3b0?}, 0x0?)
        G:/Go/pkg/mod/github.com/stephenafamo/goldmark-pdf@v0.2.0/renderer_funcs.go:138 +0xd0
github.com/stephenafamo/goldmark-pdf.(*renderer).Render.func2({0xd3dde0, 0xc0000df3b0}, 0x80?)
        G:/Go/pkg/mod/github.com/stephenafamo/goldmark-pdf@v0.2.0/renderer.go:103 +0xb6
github.com/yuin/goldmark/ast.walkHelper({0xd3dde0, 0xc0000df3b0}, 0xc000515d08)
        G:/Go/pkg/mod/github.com/yuin/goldmark@v1.5.3/ast/ast.go:492 +0x34
github.com/yuin/goldmark/ast.walkHelper({0xd3dba0, 0xc000036e00}, 0xc000515d08)
        G:/Go/pkg/mod/github.com/yuin/goldmark@v1.5.3/ast/ast.go:498 +0x8e
github.com/yuin/goldmark/ast.walkHelper({0xd3d180, 0xc0000defc0}, 0xc000515d08)
        G:/Go/pkg/mod/github.com/yuin/goldmark@v1.5.3/ast/ast.go:498 +0x8e
github.com/yuin/goldmark/ast.Walk(...)
        G:/Go/pkg/mod/github.com/yuin/goldmark@v1.5.3/ast/ast.go:487
github.com/stephenafamo/goldmark-pdf.(*renderer).Render(0xc000356440, {0xd2ede0, 0xc00008a038}, {0xc0003c4000, 0x230, 0x380}, {0xd3d180, 0xc0000defc0})
        G:/Go/pkg/mod/github.com/stephenafamo/goldmark-pdf@v0.2.0/renderer.go:98 +0x632
github.com/yuin/goldmark.(*markdown).Convert(0xc000356480, {0xc0003c4000, 0x230, 0x380}, {0xd2ede0, 0xc00008a038}, {0x0, 0x0, 0x0})

	notoFont := pdf.Font{
		CanUseForText:  true,
		CanUseForCode:  false,
		Category:       "sans-serif",
		Family:         "Noto Sans SC",
		FileRegular:    "regular",
		FileItalic:     "regular",
		FileBold:       "700",
		FileBoldItalic: "700",
		Type:           pdf.FontTypeGoogle,
	}
	config := pdf.DefaultConfig()
	err := pdf.AddFonts(ctx, config.PDF, []pdf.Font{notoFont}, nil)
	if err != nil {
		return nil, err
	}
	md := goldmark.New(
		goldmark.WithRenderer(pdf.New(
			pdf.WithConfig(config),
			pdf.WithBodyFont(pdf.FontNotoSans))),
	)
	buf := bytes.Buffer{}
	if err := md.Convert([]byte(markdownStr), &buf); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil

func (r *nodeRederFuncs) renderImage(w *Writer, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
	// while this has entering and leaving states, it doesn't appear
	// to be useful except for other markup languages to close the tag
	n := node.(*ast.Image)

	if entering {
		w.LogDebug("Image (entering)", fmt.Sprintf("Destination[%v] Title[%v]", string(n.Destination), string(n.Title)))
		// following changes suggested by @sirnewton01, issue #6
		// does file exist?
		imgPath := string(n.Destination) <--------------------------------------------------
		imgFile, err := w.ImageFS.Open(imgPath)
		if err == nil {
			defer imgFile.Close()

			width, _ := w.Pdf.GetPageSize()
			mleft, _, mright, _ := w.Pdf.GetMargins()
			maxw := width - (mleft * 2) - (mright * 2)

			format := strings.ToUpper(strings.Trim(filepath.Ext(imgPath), ".")) <-------
			w.Pdf.RegisterImage(imgPath, format, imgFile)
			w.Pdf.UseImage(imgPath, (mleft * 2), w.Pdf.GetY(), maxw, 0)
		} else {
			log.Printf("IMAGE ERROR: %v", err)
			w.LogDebug("Image (file error)", err.Error())
		}
	} else {
		w.LogDebug("Image (leaving)", "")
	}

	return ast.WalkContinue, nil
}

type HttpFs struct{}

func (f *HttpFs) Open(name string) (fs.File, error) {
	res, err := http.Get(name)
	if err != nil {
		return nil, err
	}
	return &HttpFile{r: res}, nil
}

type HttpFile struct {
	r *http.Response
}

func (f *HttpFile) Stat() (fs.FileInfo, error) {
	return &HttpInfo{r: f.r}, nil
}

func (f *HttpFile) Read(p []byte) (int, error) {
	return f.r.Body.Read(p)
}

func (f *HttpFile) Close() error {
	return f.r.Body.Close()
}

type HttpInfo struct {
	r *http.Response
}

func (i *HttpInfo) Name() string {
	fn := strings.TrimPrefix(i.r.Request.URL.Path, "/")
	if fn == "" {
		if _, params, err := mime.ParseMediaType(i.r.Header.Get("Content-Disposition")); err == nil {
			fn = params["filename"]
		}
	}
	if filepath.Ext(fn) == "" {
		mt, _, _ := mime.ParseMediaType(i.r.Header.Get("Content-Type"))
		if spl := strings.Split(mt, "/"); len(spl) > 0 {
			if fn == "" {
				fn = spl[0]
			}
			fn += "." + spl[len(spl)-1]
		}
	}
	return filepath.Base(fn)
}

func (i *HttpInfo) Size() int64 {
	return i.r.ContentLength
}

func (i *HttpInfo) Mode() fs.FileMode {
	return fs.ModeIrregular
}

func (i *HttpInfo) ModTime() time.Time {
	if t, err := time.Parse(time.RFC1123, i.r.Header.Get("Last-Modified")); err == nil {
		return t
	}
	return time.Time{}
}

func (i *HttpInfo) IsDir() bool {
	return false
}

func (i *HttpInfo) Sys() any {
	return i.r
}

import (
	"errors"
	"github.com/disintegration/imaging"
	"golang.org/x/image/webp"
	"image"
	"image/gif"
	"image/jpeg"
	"image/png"
	"io"
)

func Resize(srcMime string, src io.Reader, dst io.Writer, documentWidth int) error {
	var img image.Image
	var err error

	switch srcMime {
	case "image/jpeg":
		img, err = jpeg.Decode(src)
	case "image/gif":
		img, err = gif.Decode(src)
	case "image/png":
		img, err = png.Decode(src)
	case "image/webp":
		img, err = webp.Decode(src)
	default:
		return errors.New("unsupported input mime type: " + srcMime)
	}

	if err != nil {
		return err
	}

       if img.Bounds().Dx() < documentWidth {
              documentWidth = img.Bounds().Dx()
       }

	filter := imaging.Lanczos // best quality but slow
	img = imaging.Resize(img, documentWidth, 0, filter)
	return jpeg.Encode(dst, img, nil) // jpeg has the best compression with sufficient quality for this purpose
}

source := `"Just a test"`
markdown := goldmark.New(
		goldmark.WithRenderer(
		pdf.New(
				pdf.WithHeadingFont(pdf.GetTextFont("Times", pdf.FontTimes)),
				pdf.WithBodyFont(pdf.GetTextFont("Times", pdf.FontTimes)),
		)),
	
	)

var buf bytes.Buffer
if err := markdown.Convert([]byte(source), &buf); err != nil {
return err
}

buf.Bytes()