/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsIURI.h"

#include "nsMaiHyperlink.h"

#include "mozilla/a11y/ProxyAccessible.h"

using namespace mozilla::a11y;

/* MaiAtkHyperlink */

#define MAI_TYPE_ATK_HYPERLINK      (mai_atk_hyperlink_get_type ())

#define MAI_ATK_HYPERLINK(obj)      (G_TYPE_CHECK_INSTANCE_CAST ((obj),\

                                     MAI_TYPE_ATK_HYPERLINK, MaiAtkHyperlink))

#define MAI_ATK_HYPERLINK_CLASS(klass)  (G_TYPE_CHECK_CLASS_CAST ((klass),\

                                 MAI_TYPE_ATK_HYPERLINK, MaiAtkHyperlinkClass))

#define MAI_IS_ATK_HYPERLINK(obj)      (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\

                                        MAI_TYPE_ATK_HYPERLINK))

#define MAI_IS_ATK_HYPERLINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\

                                        MAI_TYPE_ATK_HYPERLINK))

#define MAI_ATK_HYPERLINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\

                                 MAI_TYPE_ATK_HYPERLINK, MaiAtkHyperlinkClass))

/**

 * This MaiAtkHyperlink is a thin wrapper, in the MAI namespace,

 * for AtkHyperlink

 */

struct MaiAtkHyperlink

{

    AtkHyperlink parent;

    /*

     * The MaiHyperlink whose properties and features are exported via this

     * hyperlink instance.

     */

    MaiHyperlink *maiHyperlink;

};

struct MaiAtkHyperlinkClass

{

    AtkHyperlinkClass parent_class;

};

GType mai_atk_hyperlink_get_type(void);

G_BEGIN_DECLS

/* callbacks for AtkHyperlink */

static void classInitCB(AtkHyperlinkClass *aClass);

static void finalizeCB(GObject *aObj);

/* callbacks for AtkHyperlink virtual functions */

static gchar *getUriCB(AtkHyperlink *aLink, gint aLinkIndex);

static AtkObject *getObjectCB(AtkHyperlink *aLink, gint aLinkIndex);

static gint getEndIndexCB(AtkHyperlink *aLink);

static gint getStartIndexCB(AtkHyperlink *aLink);

static gboolean isValidCB(AtkHyperlink *aLink);

static gint getAnchorCountCB(AtkHyperlink *aLink);

G_END_DECLS

static gpointer parent_class = nullptr;

static MaiHyperlink*

GetMaiHyperlink(AtkHyperlink *aHyperlink)

{

    NS_ENSURE_TRUE(MAI_IS_ATK_HYPERLINK(aHyperlink), nullptr);

    MaiHyperlink * maiHyperlink =

        MAI_ATK_HYPERLINK(aHyperlink)->maiHyperlink;

    NS_ENSURE_TRUE(maiHyperlink != nullptr, nullptr);

    NS_ENSURE_TRUE(maiHyperlink->GetAtkHyperlink() == aHyperlink, nullptr);

    return maiHyperlink;

}

GType

mai_atk_hyperlink_get_type(void)

{

    static GType type = 0;

    if (!type) {

        static const GTypeInfo tinfo = {

            sizeof(MaiAtkHyperlinkClass),

            (GBaseInitFunc)nullptr,

            (GBaseFinalizeFunc)nullptr,

            (GClassInitFunc)classInitCB,

            (GClassFinalizeFunc)nullptr,

            nullptr, /* class data */

            sizeof(MaiAtkHyperlink), /* instance size */

            0, /* nb preallocs */

            (GInstanceInitFunc)nullptr,

            nullptr /* value table */

        };

        type = g_type_register_static(ATK_TYPE_HYPERLINK,

                                      "MaiAtkHyperlink",

                                      &tinfo, GTypeFlags(0));

    }

    return type;

}

MaiHyperlink::MaiHyperlink(AccessibleOrProxy aHyperLink) :

    mHyperlink(aHyperLink),

    mMaiAtkHyperlink(nullptr)

{

    mMaiAtkHyperlink =

        reinterpret_cast<AtkHyperlink *>

                        (g_object_new(mai_atk_hyperlink_get_type(), nullptr));

    NS_ASSERTION(mMaiAtkHyperlink, "OUT OF MEMORY");

    if (!mMaiAtkHyperlink)

      return;

    MAI_ATK_HYPERLINK(mMaiAtkHyperlink)->maiHyperlink = this;

}

MaiHyperlink::~MaiHyperlink()

{

  if (mMaiAtkHyperlink) {

    MAI_ATK_HYPERLINK(mMaiAtkHyperlink)->maiHyperlink = nullptr;

    g_object_unref(mMaiAtkHyperlink);

  }

}

/* static functions for ATK callbacks */

void

classInitCB(AtkHyperlinkClass *aClass)

{

    GObjectClass *gobject_class = G_OBJECT_CLASS(aClass);

    parent_class = g_type_class_peek_parent(aClass);

    aClass->get_uri = getUriCB;

    aClass->get_object = getObjectCB;

    aClass->get_end_index = getEndIndexCB;

    aClass->get_start_index = getStartIndexCB;

    aClass->is_valid = isValidCB;

    aClass->get_n_anchors = getAnchorCountCB;

    gobject_class->finalize = finalizeCB;

}

void

finalizeCB(GObject *aObj)

{

    NS_ASSERTION(MAI_IS_ATK_HYPERLINK(aObj), "Invalid MaiAtkHyperlink");

    if (!MAI_IS_ATK_HYPERLINK(aObj))

        return;

    MaiAtkHyperlink *maiAtkHyperlink = MAI_ATK_HYPERLINK(aObj);

    maiAtkHyperlink->maiHyperlink = nullptr;

    /* call parent finalize function */

    if (G_OBJECT_CLASS (parent_class)->finalize)

        G_OBJECT_CLASS (parent_class)->finalize(aObj);

}

gchar *

getUriCB(AtkHyperlink *aLink, gint aLinkIndex)

{

  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);

  if (!maiLink)

    return nullptr;

  nsAutoCString cautoStr;

  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {

    nsCOMPtr<nsIURI> uri = hyperlink->AnchorURIAt(aLinkIndex);

    if (!uri)

      return nullptr;

    nsresult rv = uri->GetSpec(cautoStr);

    NS_ENSURE_SUCCESS(rv, nullptr);

    return g_strdup(cautoStr.get());

  }

  bool valid;

  maiLink->Proxy()->AnchorURIAt(aLinkIndex, cautoStr, &valid);

  if (!valid)

    return nullptr;

  return g_strdup(cautoStr.get());

}

AtkObject *

getObjectCB(AtkHyperlink *aLink, gint aLinkIndex)

{

  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);

  if (!maiLink) {

    return nullptr;

  }

  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {

    Accessible* anchor = hyperlink->AnchorAt(aLinkIndex);

    NS_ENSURE_TRUE(anchor, nullptr);

    return AccessibleWrap::GetAtkObject(anchor);

  }

  ProxyAccessible* anchor = maiLink->Proxy()->AnchorAt(aLinkIndex);

  return anchor ? GetWrapperFor(anchor) : nullptr;

}

gint

getEndIndexCB(AtkHyperlink *aLink)

{

  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);

  if (!maiLink)

    return false;

  if (Accessible* hyperlink = maiLink->GetAccHyperlink())

    return static_cast<gint>(hyperlink->EndOffset());

  bool valid = false;

  uint32_t endIdx = maiLink->Proxy()->EndOffset(&valid);

  return valid ? static_cast<gint>(endIdx) : -1;

}

gint

getStartIndexCB(AtkHyperlink *aLink)

{

  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);

  if (!maiLink)

    return -1;

  if (Accessible* hyperlink = maiLink->GetAccHyperlink())

    return static_cast<gint>(hyperlink->StartOffset());

  bool valid = false;

  uint32_t startIdx = maiLink->Proxy()->StartOffset(&valid);

  return valid ? static_cast<gint>(startIdx) : -1;

}

gboolean

isValidCB(AtkHyperlink *aLink)

{

  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);

  if (!maiLink)

    return false;

  if (Accessible* hyperlink = maiLink->GetAccHyperlink())

    return static_cast<gboolean>(hyperlink->IsLinkValid());

  return static_cast<gboolean>(maiLink->Proxy()->IsLinkValid());

}

gint

getAnchorCountCB(AtkHyperlink *aLink)

{

  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);

  if (!maiLink)

    return -1;

  if (Accessible* hyperlink = maiLink->GetAccHyperlink())

    return static_cast<gint>(hyperlink->AnchorCount());

  bool valid = false;

  uint32_t anchorCount = maiLink->Proxy()->AnchorCount(&valid);

  return valid ? static_cast<gint>(anchorCount) : -1;

}