//
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#import "Channel/Sources/EDOSocketChannel.h"

#include <arpa/inet.h>
#include <fcntl.h>
#include <netinet/tcp.h>
#include <sys/un.h>

#import "Channel/Sources/EDOChannel.h"
#import "Channel/Sources/EDOChannelUtil.h"
#import "Channel/Sources/EDOSocket.h"

#pragma mark - Socket Connection Extension

@interface EDOSocketChannel ()
// The dispatch io channel to send and receive I/O data from the underlying socket.
@property(readonly, nonatomic) dispatch_io_t channel;
// The dispatch queue where the receive handler block will be dispatched to.
@property(readonly, nonatomic) dispatch_queue_t handlerQueue;
@end

#pragma mark - Socket Connection

@implementation EDOSocketChannel
@dynamic valid;

+ (instancetype)channelWithSocket:(EDOSocket *)socket {
  return [self channelWithSocket:socket handlerQueue:nil];
}

+ (instancetype)channelWithSocket:(EDOSocket *)socket handlerQueue:(dispatch_queue_t)handlerQueue {
  return [[self alloc] initWithDispatchIO:[socket releaseAsDispatchIO] handlerQueue:handlerQueue];
}

- (instancetype)initWithDispatchIO:(dispatch_io_t)channel {
  return [self initWithDispatchIO:channel handlerQueue:nil];
}

- (instancetype)initWithDispatchIO:(dispatch_io_t)channel
                      handlerQueue:(dispatch_queue_t)handlerQueue {
  NSParameterAssert(channel != nil);

  self = [self initWithHandlerQueue:handlerQueue];
  if (self) {
    _channel = channel;
  }
  return self;
}

- (instancetype)initWithHandlerQueue:(dispatch_queue_t)handlerQueue {
  self = [super init];
  if (self) {
    // For internal IO and event handlers, it is equivalent to creating it as a serial queue as they
    // are not reentrant and only one block will be scheduled by dispatch io and dispatch source.
    if (handlerQueue) {
      _handlerQueue = handlerQueue;
    } else {
      // Use QOS_CLASS_USER_INITIATED as the default because eDO communication is often in the
      // critical path of user-driven test execution, and using a lower QoS can lead to priority
      // inversion issues.
      dispatch_queue_attr_t attributes = dispatch_queue_attr_make_with_qos_class(
          DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INITIATED, 0);
      _handlerQueue = dispatch_queue_create("com.google.edo.socketChannel.handler", attributes);
    }
  }
  return self;
}

- (void)dealloc {
  [self invalidate];
}

#pragma mark - EDOChannel

- (void)sendData:(NSData *)data withCompletionHandler:(EDOChannelSentHandler)handler {
  dispatch_queue_t handlerQueue = self.handlerQueue;
  if (!self.channel) {
    dispatch_async(handlerQueue, ^{
      if (handler) {
        handler(self, [NSError errorWithDomain:NSPOSIXErrorDomain code:0 userInfo:nil]);
      }
    });
    return;
  }

  dispatch_data_t totalData = EDOBuildFrameFromDataWithQueue(data, handlerQueue);
  dispatch_io_write(
      self.channel, 0, totalData, handlerQueue, ^(bool done, dispatch_data_t _, int errCode) {
        if (!done) {
          return;
        }

        if (handler) {
          dispatch_async(handlerQueue, ^{
            NSError *error;
            if (errCode != 0) {
              error = [NSError errorWithDomain:NSPOSIXErrorDomain code:errCode userInfo:nil];
            }
            handler(self, error);
          });
        }
      });
}

- (void)receiveDataWithHandler:(EDOChannelReceiveHandler)handler {
  [self receiveDataWithQueue:self.handlerQueue handler:handler];
}

- (void)receiveDataWithQueue:(dispatch_queue_t)queue
                     handler:(EDOChannelReceiveHandler _Nullable)handler {
  dispatch_queue_t handlerQueue = queue;
  dispatch_io_t channel = self.channel;
  if (!channel) {
    dispatch_async(handlerQueue, ^{
      // TODO(haowoo): Add better error code define.
      handler(self, nil,
              [NSError errorWithDomain:NSInternalInconsistencyException code:0 userInfo:nil]);
    });
    return;
  }

  // Accessing __block variable has to be atomic in order to prevent from data racing. Here because
  // ARC inserts release at the end of scope such that reads and writes can happen in different
  // threads/queues, using handlerQueue as an isolation queue to ensure its atomicity. For detail,
  // see b/171321939.
  dispatch_async(handlerQueue, ^{
    __block dispatch_data_t dataReceived;
    __block size_t remainingDataSize;
    dispatch_io_handler_t dataHandler = ^(bool done, dispatch_data_t data, int error) {
      if (error || !data) {
        if (handler) {
          dispatch_async(handlerQueue, ^{
            handler(self, nil,
                    [NSError errorWithDomain:NSPOSIXErrorDomain code:error userInfo:nil]);
          });
        }
        return;
      }
      remainingDataSize -= dispatch_data_get_size(data);
      dataReceived = dataReceived ? dispatch_data_create_concat(dataReceived, data) : data;

      if (remainingDataSize > 0) {
        return;
      }

      NSMutableData *receivedData =
          [NSMutableData dataWithCapacity:dispatch_data_get_size(dataReceived)];
      dispatch_data_apply(dataReceived, ^bool(dispatch_data_t region, size_t offset,
                                              const void *buffer, size_t size) {
        [receivedData appendBytes:buffer length:size];
        return YES;
      });

      if (handler) {
        dispatch_async(handlerQueue, ^{
          handler(self, receivedData, nil);
        });
      }
    };

    dispatch_io_handler_t frameHandler = ^(bool done, dispatch_data_t data, int error) {
      size_t payloadSize = EDOGetPayloadSizeFromFrameData(data);
      if (payloadSize > 0) {
        remainingDataSize = payloadSize;
        if (![self readDispatchIOWithDataSize:remainingDataSize handler:dataHandler] && handler) {
          handler(self, nil, nil);
        }
      } else {
        // Close the channel on errors and closed sockets.
        if (error != 0 || payloadSize == 0) {
          [self invalidate];
        }

        // Execute the block on closing the channel.
        if (payloadSize == 0 && error == 0 && handler) {
          dispatch_async(handlerQueue, ^{
            handler(self, nil, nil);
          });
        }
      }
    };

    [self readDispatchIOWithDataSize:EDOGetPayloadHeaderSize() handler:frameHandler];
  });
}

/** @see -[EDOChannel isValid] */
- (BOOL)isValid {
  @synchronized(self) {
    return _channel != NULL;
  }
}

/** @see -[EDOChannel invalidate] */
- (void)invalidate {
  @synchronized(self) {
    if (_channel) {
      dispatch_io_close(_channel, 0);
      _channel = NULL;
    }
  }
}

#pragma mark - Private

/**
 * Atomically checks the validity of the socket channel and calls dispatch_io_read if it's valid.
 *
 * @param dataSize The number of bytes to be read through dispatch_io_read.
 * @param handler  The handler to process the data read by dispatch_io_read.
 *
 * @return @c YES if dispatch_io_read is called; @c NO otherwise.
 */
- (BOOL)readDispatchIOWithDataSize:(size_t)dataSize handler:(dispatch_io_handler_t)handler {
  @synchronized(self) {
    if (_channel) {
      dispatch_io_read(_channel, 0, dataSize, _handlerQueue, handler);
    }
    return _channel != NULL;
  }
}

@end