//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2002-2011 Werner Schweer
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================

#include "instrtemplate.h"
#include "bracket.h"
#include "drumset.h"
#include "stafftype.h"
#include "style.h"
#include "sym.h"
#include "stringdata.h"
#include "utils.h"
#include "xml.h"

namespace Ms {

QList<InstrumentGroup*> instrumentGroups;
QList<MidiArticulation> articulation;                // global articulations
QList<InstrumentGenre*> instrumentGenres;

//---------------------------------------------------------
//   searchGenre
//---------------------------------------------------------

static InstrumentGenre * searchInstrumentGenre(const QString& genre)
      {
      foreach(InstrumentGenre* ig, instrumentGenres) {
            if (ig->id == genre)
                  return ig;
            }
      return nullptr;
      }

//---------------------------------------------------------
//   searchInstrumentGroup
//---------------------------------------------------------

static InstrumentGroup* searchInstrumentGroup(const QString& name)
      {
      foreach(InstrumentGroup* g, instrumentGroups) {
            if (g->id == name)
                  return g;
            }
      return nullptr;
      }

//---------------------------------------------------------
//   searchArticulation
//---------------------------------------------------------

static MidiArticulation searchArticulation(const QString& name)
      {
      foreach(MidiArticulation a, articulation) {
            if (a.name == name)
                  return a;
            }
      return MidiArticulation();
      }

//---------------------------------------------------------
//   readStaffIdx
//---------------------------------------------------------

static int readStaffIdx(XmlReader& e)
      {
      int idx = e.intAttribute("staff", 1) - 1;
      if (idx >= MAX_STAVES)
            idx = MAX_STAVES-1;
      if (idx < 0)
            idx = 0;
      return idx;
      }

//---------------------------------------------------------
//   read InstrumentGroup
//---------------------------------------------------------

void InstrumentGroup::read(XmlReader& e)
      {
      id       = e.attribute("id");
      name     = qApp->translate("InstrumentsXML", e.attribute("name").toUtf8().data());
      extended = e.intAttribute("extended", 0);

      while (e.readNextStartElement()) {
            const QStringRef& tag(e.name());
            if (tag == "instrument" || tag == "Instrument") {
                  QString sid = e.attribute("id");
                  InstrumentTemplate* t = searchTemplate(sid);
                  if (t == 0) {
                        t = new InstrumentTemplate;
                        t->articulation.append(articulation);     // init with global articulation
                        instrumentTemplates.append(t);
                        }
                  t->read(e);
                  }
            else if (tag == "ref") {
                  InstrumentTemplate* ttt = searchTemplate(e.readElementText());
                  if (ttt) {
                        InstrumentTemplate* t = new InstrumentTemplate(*ttt);
                        instrumentTemplates.append(t);
                        }
                  else
                        qDebug("instrument reference not found <%s>", e.text().toUtf8().data());
                  }
            else if (tag == "name")
                  name = qApp->translate("InstrumentsXML", e.readElementText().toUtf8().data());
            else if (tag == "extended")
                  extended = e.readInt();
            else
                  e.unknown();
            }
      if (id.isEmpty())
            id = name.toLower().replace(" ", "-");
      }

//---------------------------------------------------------
//   clear InstrumentGroup
//---------------------------------------------------------

void InstrumentGroup::clear()
      {
      qDeleteAll(instrumentTemplates);
      instrumentTemplates.clear();
      }

//---------------------------------------------------------
//   InstrumentTemplate
//---------------------------------------------------------

InstrumentTemplate::InstrumentTemplate()
      {
      staves             = 1;
      minPitchA          = 0;
      maxPitchA          = 127;
      minPitchP          = 0;
      maxPitchP          = 127;
      staffGroup         = StaffGroup::STANDARD;
      staffTypePreset    = 0;
      useDrumset         = false;
      drumset            = 0;
      extended           = false;
      singleNoteDynamics = true;

      for (int i = 0; i < MAX_STAVES; ++i) {
            clefTypes[i]._concertClef = ClefType::G;
            clefTypes[i]._transposingClef = ClefType::G;
            staffLines[i]  = 5;
            smallStaff[i]  = false;
            bracket[i]     = BracketType::NO_BRACKET;
            bracketSpan[i] = 0;
            barlineSpan[i] = false;
            }
      transpose.diatonic   = 0;
      transpose.chromatic  = 0;
      }

InstrumentTemplate::InstrumentTemplate(const InstrumentTemplate& t)
      {
      init(t);
      }

//---------------------------------------------------------
//   init
//---------------------------------------------------------

void InstrumentTemplate::init(const InstrumentTemplate& t)
      {
      longNames  = t.longNames;
      shortNames = t.shortNames;
      musicXMLid = t.musicXMLid;
      staves     = t.staves;
      extended   = t.extended;

      for (int i = 0; i < MAX_STAVES; ++i) {
            clefTypes[i]   = t.clefTypes[i];
            staffLines[i]  = t.staffLines[i];
            smallStaff[i]  = t.smallStaff[i];
            bracket[i]     = t.bracket[i];
            bracketSpan[i] = t.bracketSpan[i];
            barlineSpan[i] = t.barlineSpan[i];
            }
      minPitchA  = t.minPitchA;
      maxPitchA  = t.maxPitchA;
      minPitchP  = t.minPitchP;
      maxPitchP  = t.maxPitchP;
      transpose  = t.transpose;
      staffGroup = t.staffGroup;
      staffTypePreset   = t.staffTypePreset;
      useDrumset = t.useDrumset;
      if (t.drumset)
            drumset = new Drumset(*t.drumset);
      else
            drumset = 0;
      stringData  = t.stringData;
      midiActions = t.midiActions;
      channel     = t.channel;
      singleNoteDynamics = t.singleNoteDynamics;
      }

InstrumentTemplate::~InstrumentTemplate()
      {
      delete drumset;
      }

//---------------------------------------------------------
//   write
//---------------------------------------------------------

void InstrumentTemplate::write(XmlWriter& xml) const
      {
      xml.stag(QString("Instrument id=\"%1\"").arg(id));
      longNames.write(xml, "longName");
      shortNames.write(xml, "shortName");

      if (longNames.size() > 1)
            xml.tag("trackName", trackName);
      xml.tag("description", description);
      xml.tag("musicXMLid", musicXMLid);
      if (extended)
            xml.tag("extended", extended);
      stringData.write(xml);
      if (staves > 1)
            xml.tag("staves", staves);
      for (int i = 0; i < staves; ++i) {
            if (clefTypes[i]._concertClef == clefTypes[i]._transposingClef) {
                  QString tag = ClefInfo::tag(clefTypes[i]._concertClef);
                  if (i)
                        xml.tag(QString("clef staff=\"%1\"").arg(i+1), tag);
                  else
                        xml.tag("clef", tag);
                  }
            else {
                  QString tag1 = ClefInfo::tag(clefTypes[i]._concertClef);
                  QString tag2 = ClefInfo::tag(clefTypes[i]._transposingClef);
                  if (i) {
                        xml.tag(QString("concertClef staff=\"%1\"").arg(i+1), tag1);
                        xml.tag(QString("transposingClef staff=\"%1\"").arg(i+1), tag2);
                        }
                  else {
                        xml.tag("concertClef", tag1);
                        xml.tag("transposingClef", tag2);
                        }
                  }
            if (staffLines[i] != 5) {
                  if (i)
                        xml.tag(QString("stafflines staff=\"%1\"").arg(i+1), staffLines[i]);
                  else
                        xml.tag("stafflines", staffLines[i]);
                  }
            if (smallStaff[i]) {
                  if (i)
                        xml.tag(QString("smallStaff staff=\"%1\"").arg(i+1), smallStaff[i]);
                  else
                        xml.tag("smallStaff", smallStaff[i]);
                  }

            if (bracket[i] != BracketType::NO_BRACKET) {
                  if (i)
                        xml.tag(QString("bracket staff=\"%1\"").arg(i+1), int(bracket[i]));
                  else
                        xml.tag("bracket", int(bracket[i]));
                  }
            if (bracketSpan[i] != 0) {
                  if (i)
                        xml.tag(QString("bracketSpan staff=\"%1\"").arg(i+1), bracketSpan[i]);
                  else
                        xml.tag("bracketSpan", bracketSpan[i]);
                  }
            if (barlineSpan[i]) {
                  if (i)
                        xml.tag(QString("barlineSpan staff=\"%1\"").arg(i+1), barlineSpan[i]);
                  else
                        xml.tag("barlineSpan", barlineSpan[i]);
                  }
            }
      if (minPitchA != 0 || maxPitchA != 127)
            xml.tag("aPitchRange", QString("%1-%2").arg(int(minPitchA)).arg(int(maxPitchA)));
      if (minPitchP != 0 || maxPitchP != 127)
            xml.tag("pPitchRange", QString("%1-%2").arg(int(minPitchP)).arg(int(maxPitchP)));
      if (transpose.diatonic)
            xml.tag("transposeDiatonic", transpose.diatonic);
      if (transpose.chromatic)
            xml.tag("transposeChromatic", transpose.chromatic);
      if (useDrumset)
            xml.tag("drumset", int(useDrumset));
      if (drumset)
            drumset->save(xml);
      
      if (!singleNoteDynamics)      // default is true
            xml.tag("singleNoteDynamics", singleNoteDynamics);

      for (const NamedEventList& a : midiActions)
            a.write(xml, "MidiAction");
      for (const Channel& a : channel)
            a.write(xml, nullptr);
      for (const MidiArticulation& ma : articulation) {
            bool isGlobal = false;
            for (const MidiArticulation& ga : Ms::articulation) {
                  if (ma == ga) {
                        isGlobal = true;
                        break;
                        }
                  }
            if (!isGlobal)
                  ma.write(xml);
            }
      xml.etag();
      }

//---------------------------------------------------------
//   write1
//    output only translatable names
//---------------------------------------------------------

void InstrumentTemplate::write1(XmlWriter& xml) const
      {
      xml.stag(QString("Instrument id=\"%1\"").arg(id));
      longNames.write(xml, "longName");
      shortNames.write(xml, "shortName");
      if (longNames.size() > 1)
            xml.tag("trackName", trackName);
      xml.tag("description", description);
      xml.etag();
      }

//---------------------------------------------------------
//   read
//---------------------------------------------------------

void InstrumentTemplate::read(XmlReader& e)
      {
      id = e.attribute("id");

      while (e.readNextStartElement()) {
            const QStringRef& tag(e.name());

            if (tag == "longName" || tag == "name") {               // "name" is obsolete
                  int pos = e.intAttribute("pos", 0);
                  for (QList<StaffName>::iterator i = longNames.begin(); i != longNames.end(); ++i) {
                        if ((*i).pos() == pos) {
                              longNames.erase(i);
                              break;
                              }
                        }
                  longNames.append(StaffName(qApp->translate("InstrumentsXML", e.readElementText().toUtf8().data()), pos));
                  }
            else if (tag == "shortName" || tag == "short-name") {   // "short-name" is obsolete
                  int pos = e.intAttribute("pos", 0);
                  for (QList<StaffName>::iterator i = shortNames.begin(); i != shortNames.end(); ++i) {
                        if ((*i).pos() == pos) {
                              shortNames.erase(i);
                              break;
							  }
                        }
                  shortNames.append(StaffName(qApp->translate("InstrumentsXML", e.readElementText().toUtf8().data()), pos));
                  }
            else if (tag == "trackName")
                  trackName = qApp->translate("InstrumentsXML", e.readElementText().toUtf8().data());
            else if (tag == "description")
                  description = e.readElementText();
            else if (tag == "extended")
                  extended = e.readInt();
            else if (tag == "staves") {
                  staves = e.readInt();
                  bracketSpan[0] = staves;
//                  for (int i = 0; i < staves-1; ++i)
//                        barlineSpan[i] = true;
                  }
            else if (tag == "clef") {           // sets both transposing and concert clef
                  int idx = readStaffIdx(e);
                  QString val(e.readElementText());
                  bool ok;
                  int i = val.toInt(&ok);
                  ClefType ct = ok ? ClefType(i) : Clef::clefType(val);
                  clefTypes[idx]._concertClef = ct;
                  clefTypes[idx]._transposingClef = ct;
                  }
            else if (tag == "concertClef") {
                  int idx = readStaffIdx(e);
                  QString val(e.readElementText());
                  bool ok;
                  int i = val.toInt(&ok);
                  clefTypes[idx]._concertClef = ok ? ClefType(i) : Clef::clefType(val);
                  }
            else if (tag == "transposingClef") {
                  int idx = readStaffIdx(e);
                  QString val(e.readElementText());
                  bool ok;
                  int i = val.toInt(&ok);
                  clefTypes[idx]._transposingClef = ok ? ClefType(i) : Clef::clefType(val);
                  }
            else if (tag == "stafflines") {
                  int idx = readStaffIdx(e);
                  staffLines[idx] = e.readInt();
                  }
            else if (tag == "smallStaff") {
                  int idx = readStaffIdx(e);
                  smallStaff[idx] = e.readInt();
                  }
            else if (tag == "bracket") {
                  int idx = readStaffIdx(e);
                  bracket[idx] = BracketType(e.readInt());
                  }
            else if (tag == "bracketSpan") {
                  int idx = readStaffIdx(e);
                  bracketSpan[idx] = e.readInt();
                  }
            else if (tag == "barlineSpan") {
                  int idx = readStaffIdx(e);
                  int span = e.readInt();
                  for (int i = 0; i < span-1; ++i)
                        barlineSpan[idx+i] = true;
                  }
            else if (tag == "aPitchRange")
                  setPitchRange(e.readElementText(), &minPitchA, &maxPitchA);
            else if (tag == "pPitchRange")
                  setPitchRange(e.readElementText(), &minPitchP, &maxPitchP);
            else if (tag == "transposition") {    // obsolete
                  int i = e.readInt();
                  transpose.chromatic = i;
                  transpose.diatonic = chromatic2diatonic(i);
                  }
            else if (tag == "transposeChromatic")
                  transpose.chromatic = e.readInt();
            else if (tag == "transposeDiatonic")
                  transpose.diatonic = e.readInt();
            else if (tag == "StringData")
                  stringData.read(e);
            else if (tag == "drumset")
                  useDrumset = e.readInt();
            else if (tag == "Drum") {
                  // if we see one of this tags, a custom drumset will
                  // be created
                  if (drumset == 0) {
                        drumset = new Drumset(*smDrumset);
                        drumset->clear();
                        }
                  drumset->load(e);
                  }
            else if (tag == "MidiAction") {
                  NamedEventList a;
                  a.read(e);
                  midiActions.append(a);
                  }
            else if (tag == "Channel" || tag == "channel") {
                  Channel a;
                  a.read(e, nullptr);
                  channel.append(a);
                  }
            else if (tag == "Articulation") {
                  MidiArticulation a;
                  a.read(e);
                  int n = articulation.size();
                  int i;
                  for(i = 0; i < n; ++i) {
                        if (articulation[i].name == a.name) {
                              articulation[i] = a;
                              break;
                              }
                        }
                  if (i == n)
                        articulation.append(a);
                  }
            else if (tag == "stafftype") {
                  int staffIdx = readStaffIdx(e);
                  QString xmlPresetName = e.attribute("staffTypePreset", "");
                  QString stfGroup = e.readElementText();
                  if (stfGroup == "percussion")
                        staffGroup = StaffGroup::PERCUSSION;
                  else if (stfGroup == "tablature")
                        staffGroup = StaffGroup::TAB;
                  else
                        staffGroup = StaffGroup::STANDARD;
                  staffTypePreset = 0;
                  if (!xmlPresetName.isEmpty())
                        staffTypePreset = StaffType::presetFromXmlName(xmlPresetName);
                  if (!staffTypePreset || staffTypePreset->group() != staffGroup)
                        staffTypePreset = StaffType::getDefaultPreset(staffGroup);
                  if (staffTypePreset)
                        staffLines[staffIdx] = staffTypePreset->lines();
                  }
            else if (tag == "init") {
                  QString val(e.readElementText());
                  InstrumentTemplate* ttt = searchTemplate(val);
                  if (ttt)
                        init(*ttt);
                  else
                        qDebug("InstrumentTemplate:: init instrument <%s> not found", qPrintable(val));
                  }
            else if (tag == "musicXMLid") {
                  musicXMLid = e.readElementText();
                  }
            else if (tag == "genre") {
                  QString val(e.readElementText());
                  linkGenre(val);
                  }
            else if (tag == "singleNoteDynamics")
                  singleNoteDynamics = e.readBool();
            else
                  e.unknown();
            }
      if (channel.empty()) {
            Channel a;
            a.setChorus(0);
            a.setReverb(0);
            a.setName("normal");
            a.setProgram(0);
            a.setBank(0);
            a.setVolume(90);
            a.setPan(0);
            channel.append(a);
            }
      if (useDrumset) {
            if (channel[0].bank() == 0 && channel[0].synti().toLower() != "zerberus")
                  channel[0].setBank(128);
            }
      if (trackName.isEmpty() && !longNames.isEmpty())
            trackName = longNames[0].name();
      if (description.isEmpty() && !longNames.isEmpty())
            description = longNames[0].name();
      if (id.isEmpty())
            id = trackName.toLower().replace(" ", "-");

      if (staves == 0)
            qDebug(" 2Instrument: staves == 0 <%s>", qPrintable(id));
      }


//---------------------------------------------------------
//   setPitchRange
//---------------------------------------------------------

void InstrumentTemplate::setPitchRange(const QString& s, char* a, char* b) const
      {
      QStringList sl = s.split("-");
      if (sl.size() != 2) {
            *a = 0;
            *b = 127;
            return;
            }
      *a = sl[0].toInt();
      *b = sl[1].toInt();
      }

//---------------------------------------------------------
//   saveInstrumentTemplates
//---------------------------------------------------------

bool saveInstrumentTemplates(const QString& instrTemplates)
      {
      QFile qf(instrTemplates);
      if (!qf.open(QIODevice::WriteOnly)) {
            qDebug("cannot save instrument templates at <%s>", qPrintable(instrTemplates));
            return false;
            }
      XmlWriter xml(0, &qf);
      xml << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
      xml.stag("museScore");
      foreach(const InstrumentGenre* genre, instrumentGenres)
            genre->write(xml);
      xml << "\n";
      foreach(const MidiArticulation& a, articulation)
            a.write(xml);
      xml << "\n";
      foreach(InstrumentGroup* group, instrumentGroups) {
            xml.stag(QString("InstrumentGroup id=\"%1\"").arg(group->id));
            xml.tag("name", group->name);
            if (group->extended)
                  xml.tag("extended", group->extended);
            for (InstrumentTemplate* it : group->instrumentTemplates) {
                  it->write(xml);
                  xml << "\n";
                  }
            xml.etag();
            xml << "\n";
            }
      xml.etag();
      qf.close();
      return true;
      }

//---------------------------------------------------------
//   saveInstrumentTemplates1
//---------------------------------------------------------

bool saveInstrumentTemplates1(const QString& instrTemplates)
      {
      QFile qf(instrTemplates);
      if (!qf.open(QIODevice::WriteOnly)) {
            qDebug("cannot save instrument templates at <%s>", qPrintable(instrTemplates));
            return false;
            }
      XmlWriter xml(0, &qf);
      xml << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
      xml.stag("museScore");
      foreach(const InstrumentGenre* genre, instrumentGenres)
            genre->write1(xml);
      foreach(InstrumentGroup* group, instrumentGroups) {
            xml.stag(QString("InstrumentGroup id=\"%1\"").arg(group->id));
            xml.tag("name", group->name);
            for (InstrumentTemplate* it : group->instrumentTemplates) {
                  it->write1(xml);
                  xml << "\n";
                  }
            xml.etag();
            xml << "\n";
            }
      xml.etag();
      qf.close();
      return true;
      }

//---------------------------------------------------------
//   clearInstrumentTemplates
//---------------------------------------------------------

void clearInstrumentTemplates()
      {
      for (InstrumentGroup* g : instrumentGroups)
            g->clear();
      qDeleteAll(instrumentGroups);
      instrumentGroups.clear();
      qDeleteAll(instrumentGenres);
      instrumentGenres.clear();
      articulation.clear();
      }

//---------------------------------------------------------
//   loadInstrumentTemplates
//---------------------------------------------------------

bool loadInstrumentTemplates(const QString& instrTemplates)
      {
      QFile qf(instrTemplates);
      if (!qf.open(QIODevice::Text | QIODevice::ReadOnly)) {
            qDebug("cannot load instrument templates at <%s>", qPrintable(instrTemplates));
            return false;
            }

      XmlReader e(&qf);
      while (e.readNextStartElement()) {
            if (e.name() == "museScore") {
                  while (e.readNextStartElement()) {
                        const QStringRef& tag(e.name());
                        if (tag == "instrument-group" || tag == "InstrumentGroup") {
                              QString idGroup(e.attribute("id"));
                              InstrumentGroup* group = searchInstrumentGroup(idGroup);
                              if (group == 0) {
                                    group = new InstrumentGroup;
                                    instrumentGroups.append(group);
                                    }
                              group->read(e);
                              }
                        else if (tag == "Articulation") {
                              // read global articulation
                              QString name(e.attribute("name"));
                              MidiArticulation a = searchArticulation(name);
                              a.read(e);
                              articulation.append(a);
                              }
                        else if (tag == "Genre") {
                              QString idGenre(e.attribute("id"));
                              InstrumentGenre* genre = searchInstrumentGenre(idGenre);
                              if (!genre) {
                                    genre = new InstrumentGenre;
                                    instrumentGenres.append(genre);
                                    }
                              genre->read(e);
                              }
                        else
                              e.unknown();
                        }
                  }
            }
      // saveInstrumentTemplates1("/home/ws/mops.xml");
      return true;
      }

//---------------------------------------------------------
//   searchTemplate
//---------------------------------------------------------

InstrumentTemplate* searchTemplate(const QString& name)
      {
      for (InstrumentGroup* g : instrumentGroups) {
            for (InstrumentTemplate* it : g->instrumentTemplates) {
                  if (it->id == name)
                        return it;
                  }
            }
      return 0;
      }

//---------------------------------------------------------
//   searchTemplateForMusicXMLid
//---------------------------------------------------------

InstrumentTemplate* searchTemplateForMusicXmlId(const QString& mxmlId)
      {
      for (InstrumentGroup* g : instrumentGroups) {
            for (InstrumentTemplate* it : g->instrumentTemplates) {
                  if (it->musicXMLid == mxmlId)
                        return it;
                  }
            }
      return 0;
      }

//---------------------------------------------------------
//   linkGenre
//      link the current instrument template to the genre list specified by "genre"
//      Each genre is a list of pointers to instrument templates
//      The list of genres is at application level
//---------------------------------------------------------

void InstrumentTemplate::linkGenre(const QString& genre)
      {
      InstrumentGenre *ig = searchInstrumentGenre(genre);
      if (ig)
            genres.append(ig);
      }

//---------------------------------------------------------
//   genreMember
//      is this instrument template a member of the supplied genre
//---------------------------------------------------------

bool InstrumentTemplate::genreMember(const QString& name)
      {
            bool rVal=false;
            foreach(InstrumentGenre *instrumentGenre, genres ) {
                if(instrumentGenre->id == name) {
                      rVal = true;
                      break;
                }
            }
            return rVal;
      }

void InstrumentGenre::write(XmlWriter& xml) const
      {
      xml.stag(QString("Genre id=\"%1\"").arg(id));
      xml.tag("name", name);
      xml.etag();
      }

void InstrumentGenre::write1(XmlWriter& xml) const
      {
      write(xml);
      }

void InstrumentGenre::read(XmlReader& e)
      {
      id = e.attribute("id");
      while (e.readNextStartElement()) {
            const QStringRef& tag(e.name());
            if (tag == "name") {
                  name = qApp->translate("InstrumentsXML", e.readElementText().toUtf8().data());
            }
            else
                  e.unknown();
            }
     }

//---------------------------------------------------------
//   clefType
//---------------------------------------------------------

ClefTypeList InstrumentTemplate::clefType(int staffIdx) const
      {
      if (staffIdx < staves)
            return clefTypes[staffIdx];
      return clefTypes[0];
      }

//---------------------------------------------------------
//   defaultClef
//    traverse the instrument list for first instrument
//    with midi patch 'program'. Return the default clef
//    for this instrument.
//---------------------------------------------------------

ClefType defaultClef(int program)
      {
      if (program >= 25 && program < 32)              // this are guitars
            return ClefType::G8_VB;
      else if (program >= 33 && program < 41)         // this is bass
            return ClefType::F8_VB;

      for (InstrumentGroup* g : instrumentGroups) {
            for (InstrumentTemplate* it : g->instrumentTemplates) {
                  if (it->channel[0].bank() == 0 && it->channel[0].program() == program){
                        return (it->clefTypes[0]._concertClef);
                        }
                  }
            }
      return ClefType::G;
      }

}


