/* clang-format off */
/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* clang-format on */
/* 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/. */

#import "MOXWebAreaAccessible.h"

#import "MOXSearchInfo.h"
#import "MacUtils.h"

#include "nsAccUtils.h"
#include "nsCocoaUtils.h"
#include "DocAccessible.h"
#include "DocAccessibleParent.h"

using namespace mozilla::a11y;

@implementation MOXRootGroup

- (id)initWithParent:(MOXWebAreaAccessible*)parent {
  // The parent is always a MOXWebAreaAccessible
  mParent = parent;
  return [super init];
}

- (NSString*)moxRole {
  return NSAccessibilityGroupRole;
}

- (NSString*)moxRoleDescription {
  if ([[self moxSubrole] isEqualToString:@"AXLandmarkApplication"]) {
    return utils::LocalizedString(u"application"_ns);
  }

  return NSAccessibilityRoleDescription(NSAccessibilityGroupRole, nil);
}

- (id<mozAccessible>)moxParent {
  return mParent;
}

- (NSArray*)moxChildren {
  // Reparent the children of the web area here.
  return [mParent rootGroupChildren];
}

- (NSString*)moxIdentifier {
  // This is mostly for testing purposes to assert that this is the generated
  // root group.
  return @"root-group";
}

- (NSString*)moxSubrole {
  // Steal the subrole internally mapped to the web area.
  return [mParent moxSubrole];
}

- (id)moxHitTest:(NSPoint)point {
  return [mParent moxHitTest:point];
}

- (NSValue*)moxPosition {
  return [mParent moxPosition];
}

- (NSValue*)moxSize {
  return [mParent moxSize];
}

- (NSArray*)moxUIElementsForSearchPredicate:(NSDictionary*)searchPredicate {
  MOXSearchInfo* search =
      [[[MOXSearchInfo alloc] initWithParameters:searchPredicate
                                         andRoot:self] autorelease];

  return [search performSearch];
}

- (NSNumber*)moxUIElementCountForSearchPredicate:
    (NSDictionary*)searchPredicate {
  return [NSNumber
      numberWithDouble:[[self moxUIElementsForSearchPredicate:searchPredicate]
                           count]];
}

- (BOOL)disableChild:(id)child {
  return NO;
}

- (void)expire {
  mParent = nil;
  [super expire];
}

- (BOOL)isExpired {
  MOZ_ASSERT((mParent == nil) == mIsExpired);

  return [super isExpired];
}

@end

@implementation MOXWebAreaAccessible

- (NSString*)moxRole {
  // The OS role is AXWebArea regardless of the gecko role
  // (APPLICATION or DOCUMENT).
  // If the web area has a role of APPLICATION, its root group will
  // reflect that in a subrole/description.
  return @"AXWebArea";
}

- (NSString*)moxRoleDescription {
  // The role description is "HTML Content" regardless of the gecko role
  // (APPLICATION or DOCUMENT)
  return utils::LocalizedString(u"htmlContent"_ns);
}

- (NSURL*)moxURL {
  if ([self isExpired]) {
    return nil;
  }

  nsAutoString url;
  MOZ_ASSERT(mGeckoAccessible->IsDoc());
  nsAccUtils::DocumentURL(mGeckoAccessible, url);

  if (url.IsEmpty()) {
    return nil;
  }

  return [NSURL URLWithString:nsCocoaUtils::ToNSString(url)];
}

- (NSNumber*)moxLoaded {
  if ([self isExpired]) {
    return nil;
  }
  // We are loaded if we aren't busy or stale
  return @([self stateWithMask:(states::BUSY & states::STALE)] == 0);
}

// overrides
- (NSNumber*)moxLoadingProgress {
  if ([self isExpired]) {
    return nil;
  }

  if ([self stateWithMask:states::STALE] != 0) {
    // We expose stale state until the document is ready (DOM is loaded and tree
    // is constructed) so we indicate load hasn't started while this state is
    // present.
    return @0.0;
  }

  if ([self stateWithMask:states::BUSY] != 0) {
    // We expose state busy until the document and all its subdocuments are
    // completely loaded, so we indicate partial loading here
    return @0.5;
  }

  // if we are not busy and not stale, we are loaded
  return @1.0;
}

- (NSArray*)moxLinkUIElements {
  NSDictionary* searchPredicate = @{
    @"AXSearchKey" : @"AXLinkSearchKey",
    @"AXImmediateDescendantsOnly" : @NO,
    @"AXResultsLimit" : @(-1),
    @"AXDirection" : @"AXDirectionNext",
  };

  return [self moxUIElementsForSearchPredicate:searchPredicate];
}

- (void)handleAccessibleEvent:(uint32_t)eventType {
  switch (eventType) {
    case nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE:
      [self moxPostNotification:
                NSAccessibilityFocusedUIElementChangedNotification];
      MOZ_ASSERT(mGeckoAccessible->IsRemote() ||
                     mGeckoAccessible->AsLocal()->IsRoot() ||
                     mGeckoAccessible->AsLocal()->AsDoc()->ParentDocument(),
                 "Non-root doc without a parent!");
      if ((mGeckoAccessible->IsRemote() &&
           mGeckoAccessible->AsRemote()->IsDoc() &&
           mGeckoAccessible->AsRemote()->AsDoc()->IsTopLevel()) ||
          (mGeckoAccessible->IsLocal() &&
           !mGeckoAccessible->AsLocal()->IsRoot() &&
           mGeckoAccessible->AsLocal()->AsDoc()->ParentDocument() &&
           mGeckoAccessible->AsLocal()->AsDoc()->ParentDocument()->IsRoot())) {
        // we fire an AXLoadComplete event on top-level documents only
        [self moxPostNotification:@"AXLoadComplete"];
      } else {
        // otherwise the doc belongs to an iframe (IsTopLevelInContentProcess)
        // and we fire AXLayoutComplete instead
        [self moxPostNotification:@"AXLayoutComplete"];
      }
      break;
  }

  [super handleAccessibleEvent:eventType];
}

- (NSArray*)rootGroupChildren {
  // This method is meant to expose the doc's children to the root group.
  return [super moxChildren];
}

- (NSArray*)moxUnignoredChildren {
  if (id rootGroup = [self rootGroup]) {
    return @[ rootGroup ];
  }

  // There is no root group, expose the children here directly.
  return [super moxUnignoredChildren];
}

- (BOOL)moxBlockSelector:(SEL)selector {
  if (selector == @selector(moxSubrole)) {
    // Never expose a subrole for a web area.
    return YES;
  }

  if (selector == @selector(moxElementBusy)) {
    // Don't confuse aria-busy with a document's busy state.
    return YES;
  }

  return [super moxBlockSelector:selector];
}

- (void)moxPostNotification:(NSString*)notification {
  if (![notification isEqualToString:@"AXElementBusyChanged"]) {
    // Suppress AXElementBusyChanged since it uses gecko's BUSY state
    // to tell VoiceOver about aria-busy changes. We use that state
    // differently in documents.
    [super moxPostNotification:notification];
  }
}

- (id)rootGroup {
  if (mRole == roles::DOCUMENT) {
    // We only need a root group if our document has a role other than the
    // default document role
    return nil;
  }

  if (!mRootGroup) {
    mRootGroup = [[MOXRootGroup alloc] initWithParent:self];
  }

  return mRootGroup;
}

- (void)expire {
  [mRootGroup expire];
  [super expire];
}

- (void)dealloc {
  // This object can only be dealoced after the gecko accessible wrapper
  // reference is released, and that happens after expire is called.
  MOZ_ASSERT([self isExpired]);
  [mRootGroup release];

  [super dealloc];
}

@end
