import jcifs.internal.SmbNegotiationResponse;
import jcifs.internal.smb1.com.SmbComNegotiateResponse;

/**
 * @author mbechler
 *
 */
class SmbTreeHandleImpl implements SmbTreeHandleInternal {

    private static final Logger log = LoggerFactory.getLogger(SmbTreeHandleImpl.class);

    private final SmbResourceLocatorImpl resourceLoc;
    private final SmbTreeConnection treeConnection;

        // Arrange
        SmbFile src = mock(SmbFile.class);
        SmbFile dest = mock(SmbFile.class);

        SmbTreeHandleImpl sh = mock(SmbTreeHandleImpl.class);
        SmbTreeHandleImpl dh = mock(SmbTreeHandleImpl.class);
        when(sh.isSMB2()).thenReturn(true);
        when(dh.isSMB2()).thenReturn(true);
        when(sh.isSameTree(dh)).thenReturn(true);

     */
    public synchronized SmbTreeHandleImpl connectHost(final SmbResourceLocatorImpl loc, final String host) throws IOException {
        return connectHost(loc, host, null);
    }

    /**
     *
     * @param loc
     * @param host
     * @param referral
     * @return tree handle
     * @throws IOException
     */

        lenient().when(cfg.isTraceResourceUsage()).thenReturn(false);

        // Prepare two separate tree mocks but with same tree id
        SmbTreeHandleImpl tA = mock(SmbTreeHandleImpl.class);
        SmbTreeHandleImpl tB = mock(SmbTreeHandleImpl.class);
        lenient().when(tA.acquire()).thenReturn(tA);
        lenient().when(tB.acquire()).thenReturn(tB);
        lenient().when(tA.getTreeId()).thenReturn(treeId);

    private volatile boolean open = true;

    private SmbFileHandleImpl handle;
    private SmbPipeOutputStream output;
    private SmbPipeInputStream input;

    private final String uncPath;

    private SmbTreeHandleImpl treeHandle;

    private final int sharing = SmbConstants.DEFAULT_SHARING;

    /**
     * @param pipe
     */
    public SmbPipeHandleImpl(final SmbNamedPipe pipe) {
        this.pipe = pipe;

        // Impl case delegates to treeConnection.isSame
        SmbTreeConnection otherConn = mock(SmbTreeConnection.class);
        when(otherConn.acquire()).thenReturn(otherConn);
        SmbTreeHandleImpl other = new SmbTreeHandleImpl(resourceLoc, otherConn);

        when(treeConnection.isSame(otherConn)).thenReturn(true, false);
        assertTrue(handle.isSameTree(other));
        assertFalse(handle.isSameTree(other));

    private final SmbPipeHandleImpl handle;

    /**
     * @param handle
     * @throws SmbException
     */
    SmbPipeOutputStream(final SmbPipeHandleImpl handle, final SmbTreeHandleImpl th) throws CIFSException {
        super(handle.getPipe(), th, null, 0, 0, 0);
        this.handle = handle;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SmbFileOutputStream#isOpen()

    private final Configuration cfg;
    private final int fid;
    private final byte[] fileId;
    private boolean open = true;
    private final long tree_num; // for checking whether the tree changed
    private SmbTreeHandleImpl tree;

    private final AtomicLong usageCount = new AtomicLong(1);
    private final int flags;
    private final int access;
    private final int attrs;
    private final int options;

        if (!smbFile.isDirectory()) {
            throw new SmbException("Not a directory: " + smbFile.getPath());
        }

        try (SmbTreeHandleImpl th = smbFile.ensureTreeConnected()) {
            // Check if we can use directory leasing
            DirectoryLeaseManager dirManager = getDirectoryLeaseManager(th);

            if (rpc.retval != 0) {
                throw new SmbException(rpc.retval, true);
            }
            return rpc.getEntries();
        }
    }

    static FileEntry[] doNetShareEnum(final SmbTreeHandleImpl th) throws CIFSException {
        final SmbComTransaction req = new NetShareEnum(th.getConfig());
        final SmbComTransactionResponse resp = new NetShareEnumResponse(th.getConfig());
        th.send(req, resp);