/*
 * Copyright (C) 2009, Pino Toscano <pino@kde.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "poppler-font.h"

#include "poppler-document-private.h"

#include "FontInfo.h"

using namespace poppler;

class poppler::font_info_private
{
public:
    font_info_private()
        : type(font_info::unknown)
        , is_embedded(false)
        , is_subset(false)
    {
    }
    font_info_private(FontInfo *fi)
        : type((font_info::type_enum)fi->getType())
        , is_embedded(fi->getEmbedded())
        , is_subset(fi->getSubset())
        , emb_ref(fi->getEmbRef())
    {
        if (fi->getName()) {
            font_name = fi->getName()->getCString();
        }
        if (fi->getFile()) {
            font_file = fi->getFile()->getCString();
        }
    }

    std::string font_name;
    std::string font_file;
    font_info::type_enum type : 5;
    bool is_embedded : 1;
    bool is_subset : 1;
    Ref emb_ref;
};


class poppler::font_iterator_private
{
public:
    font_iterator_private(int start_page, document_private *dd)
        : font_info_scanner(dd->doc, start_page)
        , total_pages(dd->doc->getNumPages())
        , current_page((std::max)(start_page, 0) - 1)
    {
    }
    ~font_iterator_private()
    {
    }

    FontInfoScanner font_info_scanner;
    int total_pages;
    int current_page;
};


font_info::font_info()
    : d(new font_info_private())
{
}

font_info::font_info(font_info_private &dd)
    : d(&dd)
{
}

font_info::font_info(const font_info &fi)
    : d(new font_info_private(*fi.d))
{
}

font_info::~font_info()
{
    delete d;
}

std::string font_info::name() const
{
    return d->font_name;
}

std::string font_info::file() const
{
    return d->font_file;
}

bool font_info::is_embedded() const
{
    return d->is_embedded;
}

bool font_info::is_subset() const
{
    return d->is_subset;
}

font_info::type_enum font_info::type() const
{
    return d->type;
}

font_info& font_info::operator=(const font_info &fi)
{
    if (this != &fi) {
        *d = *fi.d;
    }
    return *this;
}


font_iterator::font_iterator(int start_page, document_private *dd)
    : d(new font_iterator_private(start_page, dd))
{
}

font_iterator::~font_iterator()
{
    delete d;
}

std::vector<font_info> font_iterator::next()
{
    ++d->current_page;

    GooList *items = d->font_info_scanner.scan(1);
    if (!items) {
        return std::vector<font_info>();
    }
    std::vector<font_info> fonts(items->getLength());
    for (int i = 0; i < items->getLength(); ++i) {
        fonts[i] = font_info(*new font_info_private((FontInfo *)items->get(i)));
    }
    deleteGooList(items, FontInfo);
    return fonts;
}

bool font_iterator::has_next() const
{
    return (d->current_page + 1) < d->total_pages;
}

int font_iterator::current_page() const
{
    return d->current_page;
}