/*
    * Copyright 2016 The Netty Project
    *
    * The Netty Project licenses this file to you 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:
    *
    *   https://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.
   */
  package io.netty.channel.kqueue;
  
  import io.netty.channel.Channel;
  import io.netty.channel.unix.DomainSocketAddress;
  import io.netty.channel.unix.ServerDomainSocketChannel;
  import io.netty.channel.unix.UnixChannelUtil;
  import io.netty.util.internal.logging.InternalLogger;
  import io.netty.util.internal.logging.InternalLoggerFactory;
  
  import java.net.SocketAddress;
  
  import static io.netty.channel.kqueue.BsdSocket.newSocketDomain;
  
  public final class KQueueServerDomainSocketChannel extends AbstractKQueueServerChannel
                                                    implements ServerDomainSocketChannel {
      private static final InternalLogger logger = InternalLoggerFactory.getInstance(
              KQueueServerDomainSocketChannel.class);
  
      private final KQueueServerChannelConfig config = new KQueueServerChannelConfig(this);
      private volatile DomainSocketAddress local;
  
      public KQueueServerDomainSocketChannel() {
          super(newSocketDomain(), false);
      }
  
      public KQueueServerDomainSocketChannel(int fd) {
          this(new BsdSocket(fd), false);
      }
  
      KQueueServerDomainSocketChannel(BsdSocket socket, boolean active) {
          super(socket, active);
      }
  
      @Override
      protected Channel newChildChannel(int fd, byte[] addr, int offset, int len) throws Exception {
          return new KQueueDomainSocketChannel(this, new BsdSocket(fd));
      }
  
      @Override
      protected DomainSocketAddress localAddress0() {
          return local;
      }
  
      @Override
      protected void doBind(SocketAddress localAddress) throws Exception {
          socket.bind(localAddress);
          socket.listen(config.getBacklog());
          local = (DomainSocketAddress) localAddress;
          active = true;
      }
  
      @Override
      protected void doClose() throws Exception {
          try {
              super.doClose();
          } finally {
              DomainSocketAddress local = this.local;
              if (local != null) {
                  // Delete the socket file if possible (only if it is not a regular file, directory or symlink).
                  boolean success = UnixChannelUtil.deleteDomainSocketFile(local.path());
                  if (!success && logger.isDebugEnabled()) {
                      logger.debug("Failed to delete a domain socket file: {}", local.path());
                  }
              }
          }
      }
  
      @Override
      public KQueueServerChannelConfig config() {
          return config;
      }
  
      @Override
      public DomainSocketAddress remoteAddress() {
          return (DomainSocketAddress) super.remoteAddress();
      }
  
      @Override
      public DomainSocketAddress localAddress() {
          return (DomainSocketAddress) super.localAddress();
      }
  }