const style = this.getMusicStyleForSection(sectionType);

await this.generateAdvancedBackgroundMusic(this.currentInstrument, duration, style);

// 添加和声
if (this.harmonyType !== 'none') {
await this.generateHarmony(text, duration, style);
}
}

// 生成高级背景音乐
async generateAdvancedBackgroundMusic(instrument, duration, style) {
return new Promise((resolve) => {
try {
// 创建更复杂的音乐结构
const chords = this.generateAdvancedChords(style, duration);
const melody = this.generateMelody(style, duration);

// 播放和弦
chords.forEach((chord, index) => {
chord.notes.forEach(note => {
this.playNoteWithEffects(note.frequency, note.duration, note.volume, instrument);
});
});

// 播放旋律
melody.forEach((note, index) => {
const startTime = this.audioContext.currentTime + (index * note.duration * 0.8);
this.playNoteWithEffects(note.frequency, note.duration, note.volume * 1.2, instrument, startTime);
});

setTimeout(() => {
resolve();
}, duration * 1000);

} catch (error) {
console.error('背景音乐生成错误:', error);
resolve();
}
});
}

// 使用效果播放音符
playNoteWithEffects(frequency, duration, volume, instrument, startTime = 0) {
const oscillator = this.audioContext.createOscillator();
const gainNode = this.audioContext.createGain();

this.configureAdvancedInstrument(oscillator, instrument);
oscillator.frequency.value = frequency;

const currentTime = this.audioContext.currentTime + startTime;

// 高级音量包络
gainNode.gain.setValueAtTime(0, currentTime);
gainNode.gain.linearRampToValueAtTime(volume, currentTime + 0.05);
gainNode.gain.exponentialRampToValueAtTime(volume * 0.3, currentTime + duration * 0.7);
gainNode.gain.exponentialRampToValueAtTime(0.001, currentTime + duration);

oscillator.connect(gainNode);
gainNode.connect(this.audioNodes.get('compressor'));

oscillator.start(currentTime);
oscillator.stop(currentTime + duration);
}

// 配置高级乐器
configureAdvancedInstrument(oscillator, instrument) {
const instrumentConfigs = {
piano: {
type: 'sine',
detune: 0,
effects: ['reverb']
},
strings: {
type: 'sawtooth',
detune: 5,
effects: ['reverb', 'delay']
},
guitar: {
type: 'square',
detune: -3,
effects: ['delay']
},
flute: {
type: 'sine',
detune: 2,
effects: ['reverb']
},
drums: {
type: 'triangle',
detune: 0,
effects: ['compression']
},
bass: {
type: 'sawtooth',
detune: -5,
effects: ['compression']
},
synth: {
type: 'square',
detune: 10,
effects: ['delay', 'chorus']
},
brass: {
type: 'sawtooth',
detune: 3,
effects: ['reverb']
}
};

const config = instrumentConfigs[instrument] || instrumentConfigs.piano;
oscillator.type = config.type;
if (oscillator.detune) {
oscillator.detune.value = config.detune;
}
}

// 生成高级和弦
generateAdvancedChords(style, duration) {
const progressions = {
verse: this.createChordProgression(['I', 'IV', 'V', 'I'], duration),
chorus: this.createChordProgression(['I', 'V', 'vi', 'IV'], duration),
'pre-chorus': this.createChordProgression(['ii', 'V', 'I'], duration),
bridge: this.createChordProgression(['vi', 'IV', 'I', 'V'], duration),
interlude: this.createChordProgression(['I', 'vi', 'IV', 'V'], duration)
};

return progressions[style] || progressions.verse;
}

// 创建和弦进行
createChordProgression(romanNumerals, duration) {
const chordMap = {
'I': [261.63, 329.63, 392.00], // C major
'ii': [293.66, 349.23, 440.00], // D minor
'IV': [349.23, 440.00, 523.25], // F major
'V': [392.00, 493.88, 587.33], // G major
'vi': [440.00, 523.25, 659.25] // A minor
};

const segmentDuration = duration / romanNumerals.length;

return romanNumerals.map((numeral, index) => {
const baseNotes = chordMap[numeral] || chordMap['I'];
return {
notes: baseNotes.map(freq => ({
frequency: freq,
duration: segmentDuration,
volume: 0.1
})),
duration: segmentDuration
};
});
}

// 生成旋律
generateMelody(style, duration) {
const scale = [261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25];
const notes = [];
const noteCount = 8;

for (let i = 0; i < noteCount; i++) {
const noteIndex = Math.floor(Math.random() * scale.length);
notes.push({
frequency: scale[noteIndex],
duration: duration / noteCount,
volume: 0.08
});
}

return notes;
}

// 生成和声
async generateHarmony(text, duration, style) {
const harmonyIntervals = {
'octave': [2, 0.5], // 八度上下
'third': [4/3, 3/4], // 三度