/*

 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.media.sound;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.sound.midi.Patch;

/**

 * This class is used to store information to describe instrument.

 * It contains list of regions and modulators.

 * It is stored inside a "ins " List Chunk inside DLS files.

 * In the DLS documentation a modulator is called articulator.

 *

 * @author Karl Helgason

 */

public final class DLSInstrument extends ModelInstrument {

    int preset = 0;

    int bank = 0;

    boolean druminstrument = false;

    byte[] guid = null;

    DLSInfo info = new DLSInfo();

    public DLSInstrument() {

        super(null, null, null, null);

    }

    public DLSInstrument(DLSSoundbank soundbank) {

        super(soundbank, null, null, null);

    }

    public DLSInfo getInfo() {

        return info;

    }

    public String getName() {

        return info.name;

    }

    public void setName(String name) {

        info.name = name;

    }

    public ModelPatch getPatch() {

        return new ModelPatch(bank, preset, druminstrument);

    }

    public void setPatch(Patch patch) {

        if (patch instanceof ModelPatch && ((ModelPatch)patch).isPercussion()) {

            druminstrument = true;

            bank = patch.getBank();

            preset = patch.getProgram();

        } else {

            druminstrument = false;

            bank = patch.getBank();

            preset = patch.getProgram();

        }

    }

    public Object getData() {

        return null;

    }

    public List<DLSRegion> getRegions() {

        return regions;

    }

    public List<DLSModulator> getModulators() {

        return modulators;

    }

    public String toString() {

        if (druminstrument)

            return "Drumkit: " + info.name

                    + " bank #" + bank + " preset #" + preset;

        else

            return "Instrument: " + info.name

                    + " bank #" + bank + " preset #" + preset;

    }

    private ModelIdentifier convertToModelDest(int dest) {

        if (dest == DLSModulator.CONN_DST_NONE)

            return null;

        if (dest == DLSModulator.CONN_DST_GAIN)

            return ModelDestination.DESTINATION_GAIN;

        if (dest == DLSModulator.CONN_DST_PITCH)

            return ModelDestination.DESTINATION_PITCH;

        if (dest == DLSModulator.CONN_DST_PAN)

            return ModelDestination.DESTINATION_PAN;

        if (dest == DLSModulator.CONN_DST_LFO_FREQUENCY)

            return ModelDestination.DESTINATION_LFO1_FREQ;

        if (dest == DLSModulator.CONN_DST_LFO_STARTDELAY)

            return ModelDestination.DESTINATION_LFO1_DELAY;

        if (dest == DLSModulator.CONN_DST_EG1_ATTACKTIME)

            return ModelDestination.DESTINATION_EG1_ATTACK;

        if (dest == DLSModulator.CONN_DST_EG1_DECAYTIME)

            return ModelDestination.DESTINATION_EG1_DECAY;

        if (dest == DLSModulator.CONN_DST_EG1_RELEASETIME)

            return ModelDestination.DESTINATION_EG1_RELEASE;

        if (dest == DLSModulator.CONN_DST_EG1_SUSTAINLEVEL)

            return ModelDestination.DESTINATION_EG1_SUSTAIN;

        if (dest == DLSModulator.CONN_DST_EG2_ATTACKTIME)

            return ModelDestination.DESTINATION_EG2_ATTACK;

        if (dest == DLSModulator.CONN_DST_EG2_DECAYTIME)

            return ModelDestination.DESTINATION_EG2_DECAY;

        if (dest == DLSModulator.CONN_DST_EG2_RELEASETIME)

            return ModelDestination.DESTINATION_EG2_RELEASE;

        if (dest == DLSModulator.CONN_DST_EG2_SUSTAINLEVEL)

            return ModelDestination.DESTINATION_EG2_SUSTAIN;

        // DLS2 Destinations

        if (dest == DLSModulator.CONN_DST_KEYNUMBER)

            return ModelDestination.DESTINATION_KEYNUMBER;

        if (dest == DLSModulator.CONN_DST_CHORUS)

            return ModelDestination.DESTINATION_CHORUS;

        if (dest == DLSModulator.CONN_DST_REVERB)

            return ModelDestination.DESTINATION_REVERB;

        if (dest == DLSModulator.CONN_DST_VIB_FREQUENCY)

            return ModelDestination.DESTINATION_LFO2_FREQ;

        if (dest == DLSModulator.CONN_DST_VIB_STARTDELAY)

            return ModelDestination.DESTINATION_LFO2_DELAY;

        if (dest == DLSModulator.CONN_DST_EG1_DELAYTIME)

            return ModelDestination.DESTINATION_EG1_DELAY;

        if (dest == DLSModulator.CONN_DST_EG1_HOLDTIME)

            return ModelDestination.DESTINATION_EG1_HOLD;

        if (dest == DLSModulator.CONN_DST_EG1_SHUTDOWNTIME)

            return ModelDestination.DESTINATION_EG1_SHUTDOWN;

        if (dest == DLSModulator.CONN_DST_EG2_DELAYTIME)

            return ModelDestination.DESTINATION_EG2_DELAY;

        if (dest == DLSModulator.CONN_DST_EG2_HOLDTIME)

            return ModelDestination.DESTINATION_EG2_HOLD;

        if (dest == DLSModulator.CONN_DST_FILTER_CUTOFF)

            return ModelDestination.DESTINATION_FILTER_FREQ;

        if (dest == DLSModulator.CONN_DST_FILTER_Q)

            return ModelDestination.DESTINATION_FILTER_Q;

        return null;

    }

    private ModelIdentifier convertToModelSrc(int src) {

        if (src == DLSModulator.CONN_SRC_NONE)

            return null;

        if (src == DLSModulator.CONN_SRC_LFO)

            return ModelSource.SOURCE_LFO1;

        if (src == DLSModulator.CONN_SRC_KEYONVELOCITY)

            return ModelSource.SOURCE_NOTEON_VELOCITY;

        if (src == DLSModulator.CONN_SRC_KEYNUMBER)

            return ModelSource.SOURCE_NOTEON_KEYNUMBER;

        if (src == DLSModulator.CONN_SRC_EG1)

            return ModelSource.SOURCE_EG1;

        if (src == DLSModulator.CONN_SRC_EG2)

            return ModelSource.SOURCE_EG2;

        if (src == DLSModulator.CONN_SRC_PITCHWHEEL)

            return ModelSource.SOURCE_MIDI_PITCH;

        if (src == DLSModulator.CONN_SRC_CC1)

            return new ModelIdentifier("midi_cc", "1", 0);

        if (src == DLSModulator.CONN_SRC_CC7)

            return new ModelIdentifier("midi_cc", "7", 0);

        if (src == DLSModulator.CONN_SRC_CC10)

            return new ModelIdentifier("midi_cc", "10", 0);

        if (src == DLSModulator.CONN_SRC_CC11)

            return new ModelIdentifier("midi_cc", "11", 0);

        if (src == DLSModulator.CONN_SRC_RPN0)

            return new ModelIdentifier("midi_rpn", "0", 0);

        if (src == DLSModulator.CONN_SRC_RPN1)

            return new ModelIdentifier("midi_rpn", "1", 0);

        if (src == DLSModulator.CONN_SRC_POLYPRESSURE)

            return ModelSource.SOURCE_MIDI_POLY_PRESSURE;

        if (src == DLSModulator.CONN_SRC_CHANNELPRESSURE)

            return ModelSource.SOURCE_MIDI_CHANNEL_PRESSURE;

        if (src == DLSModulator.CONN_SRC_VIBRATO)

            return ModelSource.SOURCE_LFO2;

        if (src == DLSModulator.CONN_SRC_MONOPRESSURE)

            return ModelSource.SOURCE_MIDI_CHANNEL_PRESSURE;

        if (src == DLSModulator.CONN_SRC_CC91)

            return new ModelIdentifier("midi_cc", "91", 0);

        if (src == DLSModulator.CONN_SRC_CC93)

            return new ModelIdentifier("midi_cc", "93", 0);

        return null;

    }

    private ModelConnectionBlock convertToModel(DLSModulator mod) {

        ModelIdentifier source = convertToModelSrc(mod.getSource());

        ModelIdentifier control = convertToModelSrc(mod.getControl());

        ModelIdentifier destination_id =

                convertToModelDest(mod.getDestination());

        int scale = mod.getScale();

        double f_scale;

        if (scale == Integer.MIN_VALUE)

            f_scale = Double.NEGATIVE_INFINITY;

        else

            f_scale = scale / 65536.0;

        if (destination_id != null) {

            ModelSource src = null;

            ModelSource ctrl = null;

            ModelConnectionBlock block = new ModelConnectionBlock();

            if (control != null) {

                ModelSource s = new ModelSource();

                if (control == ModelSource.SOURCE_MIDI_PITCH) {

                    ((ModelStandardTransform)s.getTransform()).setPolarity(

                            ModelStandardTransform.POLARITY_BIPOLAR);

                } else if (control == ModelSource.SOURCE_LFO1

                        || control == ModelSource.SOURCE_LFO2) {

                    ((ModelStandardTransform)s.getTransform()).setPolarity(

                            ModelStandardTransform.POLARITY_BIPOLAR);

                }

                s.setIdentifier(control);

                block.addSource(s);

                ctrl = s;

            }

            if (source != null) {

                ModelSource s = new ModelSource();

                if (source == ModelSource.SOURCE_MIDI_PITCH) {

                    ((ModelStandardTransform)s.getTransform()).setPolarity(

                            ModelStandardTransform.POLARITY_BIPOLAR);

                } else if (source == ModelSource.SOURCE_LFO1

                        || source == ModelSource.SOURCE_LFO2) {

                    ((ModelStandardTransform)s.getTransform()).setPolarity(

                            ModelStandardTransform.POLARITY_BIPOLAR);

                }

                s.setIdentifier(source);

                block.addSource(s);

                src = s;

            }

            ModelDestination destination = new ModelDestination();

            destination.setIdentifier(destination_id);

            block.setDestination(destination);

            if (mod.getVersion() == 1) {

                //if (mod.getTransform() ==  DLSModulator.CONN_TRN_CONCAVE) {

                //    ((ModelStandardTransform)destination.getTransform())

                //            .setTransform(

                //            ModelStandardTransform.TRANSFORM_CONCAVE);

                //}

                if (mod.getTransform() == DLSModulator.CONN_TRN_CONCAVE) {

                    if (src != null) {

                        ((ModelStandardTransform)src.getTransform())

                                .setTransform(

                                    ModelStandardTransform.TRANSFORM_CONCAVE);

                        ((ModelStandardTransform)src.getTransform())

                                .setDirection(

                                    ModelStandardTransform.DIRECTION_MAX2MIN);

                    }

                    if (ctrl != null) {

                        ((ModelStandardTransform)ctrl.getTransform())

                                .setTransform(

                                    ModelStandardTransform.TRANSFORM_CONCAVE);

                        ((ModelStandardTransform)ctrl.getTransform())

                                .setDirection(

                                    ModelStandardTransform.DIRECTION_MAX2MIN);

                    }

                }

            } else if (mod.getVersion() == 2) {

                int transform = mod.getTransform();

                int src_transform_invert = (transform >> 15) & 1;

                int src_transform_bipolar = (transform >> 14) & 1;

                int src_transform = (transform >> 10) & 8;

                int ctr_transform_invert = (transform >> 9) & 1;

                int ctr_transform_bipolar = (transform >> 8) & 1;

                int ctr_transform = (transform >> 4) & 8;

                if (src != null) {

                    int trans = ModelStandardTransform.TRANSFORM_LINEAR;

                    if (src_transform == DLSModulator.CONN_TRN_SWITCH)

                        trans = ModelStandardTransform.TRANSFORM_SWITCH;

                    if (src_transform == DLSModulator.CONN_TRN_CONCAVE)

                        trans = ModelStandardTransform.TRANSFORM_CONCAVE;

                    if (src_transform == DLSModulator.CONN_TRN_CONVEX)

                        trans = ModelStandardTransform.TRANSFORM_CONVEX;

                    ((ModelStandardTransform)src.getTransform())

                            .setTransform(trans);

                    ((ModelStandardTransform)src.getTransform())

                            .setPolarity(src_transform_bipolar == 1);

                    ((ModelStandardTransform)src.getTransform())

                            .setDirection(src_transform_invert == 1);

                }

                if (ctrl != null) {

                    int trans = ModelStandardTransform.TRANSFORM_LINEAR;

                    if (ctr_transform == DLSModulator.CONN_TRN_SWITCH)

                        trans = ModelStandardTransform.TRANSFORM_SWITCH;

                    if (ctr_transform == DLSModulator.CONN_TRN_CONCAVE)

                        trans = ModelStandardTransform.TRANSFORM_CONCAVE;

                    if (ctr_transform == DLSModulator.CONN_TRN_CONVEX)

                        trans = ModelStandardTransform.TRANSFORM_CONVEX;

                    ((ModelStandardTransform)ctrl.getTransform())

                            .setTransform(trans);

                    ((ModelStandardTransform)ctrl.getTransform())

                            .setPolarity(ctr_transform_bipolar == 1);

                    ((ModelStandardTransform)ctrl.getTransform())

                            .setDirection(ctr_transform_invert == 1);

                }

                /* No output transforms are defined the DLS Level 2

                int out_transform = transform % 8;

                int trans = ModelStandardTransform.TRANSFORM_LINEAR;

                if (out_transform == DLSModulator.CONN_TRN_SWITCH)

                    trans = ModelStandardTransform.TRANSFORM_SWITCH;

                if (out_transform == DLSModulator.CONN_TRN_CONCAVE)

                    trans = ModelStandardTransform.TRANSFORM_CONCAVE;

                if (out_transform == DLSModulator.CONN_TRN_CONVEX)

                    trans = ModelStandardTransform.TRANSFORM_CONVEX;

                if (ctrl != null) {

                    ((ModelStandardTransform)destination.getTransform())

                            .setTransform(trans);

                }

                */

            }

            block.setScale(f_scale);

            return block;

        }

        return null;

    }

    public ModelPerformer[] getPerformers() {

        for (DLSModulator mod: getModulators()) {

            modmap.put(mod.getSource() + "x" + mod.getControl() + "=" +

                    mod.getDestination(), mod);

        }

        for (DLSRegion zone: regions) {

            ModelPerformer performer = new ModelPerformer();

            performer.setName(zone.getSample().getName());

            performer.setSelfNonExclusive((zone.getFusoptions() &

                    DLSRegion.OPTION_SELFNONEXCLUSIVE) != 0);

            performer.setExclusiveClass(zone.getExclusiveClass());

            performer.setKeyFrom(zone.getKeyfrom());

            performer.setKeyTo(zone.getKeyto());

            performer.setVelFrom(zone.getVelfrom());

            performer.setVelTo(zone.getVelto());

            insmodmap.clear();

            insmodmap.putAll(modmap);

            for (DLSModulator mod: zone.getModulators()) {

                insmodmap.put(mod.getSource() + "x" + mod.getControl() + "=" +

                        mod.getDestination(), mod);

            }

            List<ModelConnectionBlock> blocks = performer.getConnectionBlocks();

            for (DLSModulator mod: insmodmap.values()) {

                ModelConnectionBlock p = convertToModel(mod);

                if (p != null)

                    blocks.add(p);

            }

            DLSSample sample = zone.getSample();

            DLSSampleOptions sampleopt = zone.getSampleoptions();

            if (sampleopt == null)

                sampleopt = sample.getSampleoptions();

            ModelByteBuffer buff = sample.getDataBuffer();

            float pitchcorrection = (-sampleopt.unitynote * 100) +

                    sampleopt.finetune;

            ModelByteBufferWavetable osc = new ModelByteBufferWavetable(buff,

                    sample.getFormat(), pitchcorrection);

            osc.setAttenuation(osc.getAttenuation() / 65536f);

            if (sampleopt.getLoops().size() != 0) {

                DLSSampleLoop loop = sampleopt.getLoops().get(0);

                osc.setLoopStart((int)loop.getStart());

                osc.setLoopLength((int)loop.getLength());

                if (loop.getType() == DLSSampleLoop.LOOP_TYPE_FORWARD)

                    osc.setLoopType(ModelWavetable.LOOP_TYPE_FORWARD);

                if (loop.getType() == DLSSampleLoop.LOOP_TYPE_RELEASE)

                    osc.setLoopType(ModelWavetable.LOOP_TYPE_RELEASE);

                else

                    osc.setLoopType(ModelWavetable.LOOP_TYPE_FORWARD);

            }

            performer.getConnectionBlocks().add(

                    new ModelConnectionBlock(SoftFilter.FILTERTYPE_LP12,

                        new ModelDestination(

                            new ModelIdentifier("filter", "type", 1))));

            performer.getOscillators().add(osc);

            performers.add(performer);

        }

        return performers.toArray(new ModelPerformer[performers.size()]);

    }

    public byte[] getGuid() {

        return guid == null ? null : Arrays.copyOf(guid, guid.length);

    }

    public void setGuid(byte[] guid) {

        this.guid = guid == null ? null : Arrays.copyOf(guid, guid.length);

    }

}