// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#import "FLTGoogleMapTileOverlayController.h"
#import "JsonConversions.h"

static void InterpretTileOverlayOptions(NSDictionary *data,
                                        id<FLTGoogleMapTileOverlayOptionsSink> sink,
                                        NSObject<FlutterPluginRegistrar> *registrar) {
  NSNumber *visible = data[@"visible"];
  if (visible != nil) {
    [sink setVisible:visible.boolValue];
  }

  NSNumber *transparency = data[@"transparency"];
  if (transparency != nil) {
    [sink setTransparency:transparency.floatValue];
  }

  NSNumber *zIndex = data[@"zIndex"];
  if (zIndex != nil) {
    [sink setZIndex:zIndex.intValue];
  }

  NSNumber *fadeIn = data[@"fadeIn"];
  if (fadeIn != nil) {
    [sink setFadeIn:fadeIn.boolValue];
  }

  NSNumber *tileSize = data[@"tileSize"];
  if (tileSize != nil) {
    [sink setTileSize:tileSize.integerValue];
  }
}

@interface FLTGoogleMapTileOverlayController ()

@property(strong, nonatomic) GMSTileLayer *layer;
@property(weak, nonatomic) GMSMapView *mapView;

@end

@implementation FLTGoogleMapTileOverlayController

- (instancetype)initWithTileLayer:(GMSTileLayer *)tileLayer mapView:(GMSMapView *)mapView {
  self = [super init];
  if (self) {
    self.layer = tileLayer;
    self.mapView = mapView;
  }
  return self;
}

- (void)removeTileOverlay {
  self.layer.map = nil;
}

- (void)clearTileCache {
  [self.layer clearTileCache];
}

- (NSDictionary *)getTileOverlayInfo {
  NSMutableDictionary *info = [[NSMutableDictionary alloc] init];
  BOOL visible = self.layer.map != nil;
  info[@"visible"] = @(visible);
  info[@"fadeIn"] = @(self.layer.fadeIn);
  float transparency = 1.0 - self.layer.opacity;
  info[@"transparency"] = @(transparency);
  info[@"zIndex"] = @(self.layer.zIndex);
  return info;
}

#pragma mark - FLTGoogleMapTileOverlayOptionsSink methods

- (void)setFadeIn:(BOOL)fadeIn {
  self.layer.fadeIn = fadeIn;
}

- (void)setTransparency:(float)transparency {
  float opacity = 1.0 - transparency;
  self.layer.opacity = opacity;
}

- (void)setVisible:(BOOL)visible {
  self.layer.map = visible ? self.mapView : nil;
}

- (void)setZIndex:(int)zIndex {
  self.layer.zIndex = zIndex;
}

- (void)setTileSize:(NSInteger)tileSize {
  self.layer.tileSize = tileSize;
}
@end

@interface FLTTileProviderController ()

@property(weak, nonatomic) FlutterMethodChannel *methodChannel;
@property(copy, nonatomic, readwrite) NSString *tileOverlayId;

@end

@implementation FLTTileProviderController

- (instancetype)init:(FlutterMethodChannel *)methodChannel tileOverlayId:(NSString *)tileOverlayId {
  self = [super init];
  if (self) {
    self.methodChannel = methodChannel;
    self.tileOverlayId = tileOverlayId;
  }
  return self;
}

#pragma mark - GMSTileLayer method

- (void)requestTileForX:(NSUInteger)x
                      y:(NSUInteger)y
                   zoom:(NSUInteger)zoom
               receiver:(id<GMSTileReceiver>)receiver {
  [self.methodChannel
      invokeMethod:@"tileOverlay#getTile"
         arguments:@{
           @"tileOverlayId" : self.tileOverlayId,
           @"x" : @(x),
           @"y" : @(y),
           @"zoom" : @(zoom)
         }
            result:^(id _Nullable result) {
              UIImage *tileImage;
              if ([result isKindOfClass:[NSDictionary class]]) {
                FlutterStandardTypedData *typedData = (FlutterStandardTypedData *)result[@"data"];
                if (typedData == nil) {
                  tileImage = kGMSTileLayerNoTile;
                } else {
                  tileImage = [UIImage imageWithData:typedData.data];
                }
              } else {
                if ([result isKindOfClass:[FlutterError class]]) {
                  FlutterError *error = (FlutterError *)result;
                  NSLog(@"Can't get tile: errorCode = %@, errorMessage = %@, details = %@",
                        [error code], [error message], [error details]);
                }
                if ([result isKindOfClass:[FlutterMethodNotImplemented class]]) {
                  NSLog(@"Can't get tile: notImplemented");
                }
                tileImage = kGMSTileLayerNoTile;
              }

              [receiver receiveTileWithX:x y:y zoom:zoom image:tileImage];
            }];
}

@end

@interface FLTTileOverlaysController ()

@property(strong, nonatomic) NSMutableDictionary *tileOverlayIdToController;
@property(weak, nonatomic) FlutterMethodChannel *methodChannel;
@property(weak, nonatomic) NSObject<FlutterPluginRegistrar> *registrar;
@property(weak, nonatomic) GMSMapView *mapView;

@end

@implementation FLTTileOverlaysController

- (instancetype)init:(FlutterMethodChannel *)methodChannel
             mapView:(GMSMapView *)mapView
           registrar:(NSObject<FlutterPluginRegistrar> *)registrar {
  self = [super init];
  if (self) {
    self.methodChannel = methodChannel;
    self.mapView = mapView;
    self.tileOverlayIdToController = [[NSMutableDictionary alloc] init];
    self.registrar = registrar;
  }
  return self;
}

- (void)addTileOverlays:(NSArray *)tileOverlaysToAdd {
  for (NSDictionary *tileOverlay in tileOverlaysToAdd) {
    NSString *tileOverlayId = [FLTTileOverlaysController getTileOverlayId:tileOverlay];
    FLTTileProviderController *tileProvider =
        [[FLTTileProviderController alloc] init:self.methodChannel tileOverlayId:tileOverlayId];
    FLTGoogleMapTileOverlayController *controller =
        [[FLTGoogleMapTileOverlayController alloc] initWithTileLayer:tileProvider
                                                             mapView:self.mapView];
    InterpretTileOverlayOptions(tileOverlay, controller, self.registrar);
    self.tileOverlayIdToController[tileOverlayId] = controller;
  }
}

- (void)changeTileOverlays:(NSArray *)tileOverlaysToChange {
  for (NSDictionary *tileOverlay in tileOverlaysToChange) {
    NSString *tileOverlayId = [FLTTileOverlaysController getTileOverlayId:tileOverlay];
    FLTGoogleMapTileOverlayController *controller = self.tileOverlayIdToController[tileOverlayId];
    if (!controller) {
      continue;
    }
    InterpretTileOverlayOptions(tileOverlay, controller, self.registrar);
  }
}
- (void)removeTileOverlayIds:(NSArray *)tileOverlayIdsToRemove {
  for (NSString *tileOverlayId in tileOverlayIdsToRemove) {
    FLTGoogleMapTileOverlayController *controller = self.tileOverlayIdToController[tileOverlayId];
    if (!controller) {
      continue;
    }
    [controller removeTileOverlay];
    [self.tileOverlayIdToController removeObjectForKey:tileOverlayId];
  }
}

- (void)clearTileCache:(NSString *)tileOverlayId {
  FLTGoogleMapTileOverlayController *controller = self.tileOverlayIdToController[tileOverlayId];
  if (!controller) {
    return;
  }
  [controller clearTileCache];
}

- (nullable NSDictionary *)getTileOverlayInfo:(NSString *)tileverlayId {
  if (self.tileOverlayIdToController[tileverlayId] == nil) {
    return nil;
  }
  return [self.tileOverlayIdToController[tileverlayId] getTileOverlayInfo];
}

+ (NSString *)getTileOverlayId:(NSDictionary *)tileOverlay {
  return tileOverlay[@"tileOverlayId"];
}

@end