module dft;

import std.file;

private struct dft_font_t
{
    int line_height;
    int baseline_offset;
};

private struct dft_glyph_t
{
    ubyte * bitmap;
    int width;
    int height;
    int left;
    int top;
    int advance;
};

private extern(C) dft_glyph_t * dft_glyph_new(dft_font_t * dft_font, uint char_code, int outline_size);
private extern(C) void dft_glyph_free(dft_glyph_t * dft_glyph);
private extern(C) dft_font_t * dft_font_new(const ubyte * file_data, uint file_size, int font_size);
private extern(C) void dft_font_free(dft_font_t * dft_font);

class Font
{
    class Glyph
    {
        dft_glyph_t * m_dft_glyph;

        private this(Font font, uint char_code, int outline_size)
        {
            m_dft_glyph = dft_glyph_new(font.m_dft_font, char_code, outline_size);
        }

        ~this()
        {
            dft_glyph_free(m_dft_glyph);
        }

        @property int width()
        {
            return m_dft_glyph.width;
        }

        @property int height()
        {
            return m_dft_glyph.height;
        }

        @property int left()
        {
            return m_dft_glyph.left;
        }

        @property int top()
        {
            return m_dft_glyph.top;
        }

        @property const(ubyte)[] bitmap()
        {
            int n_bytes = width * height;
            return m_dft_glyph.bitmap[0..n_bytes];
        }
    }

    dft_font_t * m_dft_font;

    this(const(ubyte)[] file_data, int font_size)
    {
        m_dft_font = dft_font_new(file_data.ptr, cast(uint)file_data.length, font_size);
    }

    this(string file_name, int font_size)
    {
        const(ubyte)[] file_data = cast(const(ubyte)[])std.file.read(file_name);
        this(file_data, font_size);
    }

    ~this()
    {
        dft_font_free(m_dft_font);
    }

    @property int line_height()
    {
        return m_dft_font.line_height;
    }

    @property int baseline_offset()
    {
        return m_dft_font.baseline_offset;
    }
}