/*

 * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.jmx.namespace.serial;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InvalidClassException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.ObjectStreamClass;

import java.io.OutputStream;

import java.util.LinkedList;

import java.util.Queue;

import javax.management.ObjectName;

/**

 * Class SerialRewritingProcessor. A RewritingProcessor that uses

 * Java Serialization to rewrite ObjectNames contained in

 * input & results...

 * <p><b>

 * This API is a Sun internal API and is subject to changes without notice.

 * </b></p>

 * @since 1.7

 */

class SerialRewritingProcessor extends RewritingProcessor {

    private static class CloneOutput extends ObjectOutputStream {

        Queue<Class<?>> classQueue = new LinkedList<Class<?>>();

        CloneOutput(OutputStream out) throws IOException {

            super(out);

        }

        @Override

        protected void annotateClass(Class<?> c) {

            classQueue.add(c);

        }

        @Override

        protected void annotateProxyClass(Class<?> c) {

            classQueue.add(c);

        }

    }

    private static class CloneInput extends ObjectInputStream {

        private final CloneOutput output;

        CloneInput(InputStream in, CloneOutput output) throws IOException {

            super(in);

            this.output = output;

        }

        @Override

        protected Class<?> resolveClass(ObjectStreamClass osc)

        throws IOException, ClassNotFoundException {

            Class<?> c = output.classQueue.poll();

            String expected = osc.getName();

            String found = (c == null) ? null : c.getName();

            if (!expected.equals(found)) {

                throw new InvalidClassException("Classes desynchronized: " +

                        "found " + found + " when expecting " + expected);

            }

            return c;

        }

        @Override

        protected Class<?> resolveProxyClass(String[] interfaceNames)

        throws IOException, ClassNotFoundException {

            return output.classQueue.poll();

        }

    }

    final String targetPrefix;

    final String sourcePrefix;

    final boolean identity;

    public SerialRewritingProcessor(String targetDirName) {

        this(targetDirName,null);

    }

    /** Creates a new instance of SerialRewritingProcessor */

    public SerialRewritingProcessor(final String remove, final String add) {

        super(new RoutingOnlyProcessor(remove,add));

        this.targetPrefix = remove;

        this.sourcePrefix = add;

        identity = targetPrefix.equals(sourcePrefix);

    }

    private <T> T  switchContext(T result, String from,String to)

            throws IOException, ClassNotFoundException {

        final ByteArrayOutputStream baos = new ByteArrayOutputStream();

        final CloneOutput ostream = new CloneOutput(baos);

        JMXNamespaceContext.serialize(ostream,result,from,null);

        ostream.flush();

        final byte[] bytes = baos.toByteArray();

        final ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

        final CloneInput istream = new CloneInput(bais, ostream);

        @SuppressWarnings("unchecked")

        final T clone = (T) JMXNamespaceContext.deserialize(istream,null,to);

        return clone;

    }

    @Override

    @SuppressWarnings("unchecked")

    public <T> T rewriteOutput(T result) {

        if (identity) return result;

        return (T) processOutput(result);

    }

    private Object processOutput(Object result) {

        try {

            if (result instanceof ObjectName)

                return toTargetContext((ObjectName) result);

            return switchContext(result,sourcePrefix,targetPrefix);

        } catch (ClassNotFoundException x) {

            throw new IllegalArgumentException("Can't process result: "+x,x);

        } catch (IOException x) {

            throw new IllegalArgumentException("Can't process result: "+x,x);

        }

    }

    @Override

    @SuppressWarnings("unchecked")

    public <T> T rewriteInput(T input) {

        if (identity) return input;

        return (T) processInput(input);

    }

    private Object processInput(Object input) {

        try {

            if (input instanceof ObjectName)

                return toSourceContext((ObjectName) input);

            return switchContext(input,targetPrefix,sourcePrefix);

        } catch (ClassNotFoundException x) {

            throw new IllegalArgumentException("Can't process input: "+x,x);

        } catch (IOException x) {

            throw new IllegalArgumentException("Can't process input: "+x,x);

        }

    }

}