make me an application to extract the key, tempo and chord progressions from an audio (WAV or MP3) uploaded file, detecting all chord progressions by bars and playing and showing the wave progress with its chord progressions . and suggest chord progressio

Creating an application to extract musical elements like key, tempo, and chord progressions from audio files, and processing MIDI files for suggested chord progressions, is indeed a complex task, but it can be achieved with the right tools and programming languages. Below is a high-level overview of how you could structure such an application:

### Components Required

1. **Audio Processing**: 
   - You would use libraries like `Librosa` or `Essentia` in Python to extract audio features.
   - For chord recognition, you may want to utilize libraries like `Chordify` or implement a machine learning model.

2. **MIDI Processing**: 
   - For MIDI file analysis, you can use `mido` or `pretty_midi` in Python to extract note information and suggest compatible chord progressions.

3. **Web Framework**: 
   - Flask or Django to create a web application where users can upload files.

4. **Frontend Visualization**: 
   - Use JavaScript libraries (like Wavesurfer.js) for waveform visualization and to show chord progressions on the UI.

### High-Level Steps

1. **File Upload**
   - Create a file upload form for WAV/MP3 and MIDI files.

2. **Extract Key, Tempo and Chord Progressions**
   - Use audio processing library to load the audio file.
   - Calculate the tempo using `librosa.beat.bpm` or similar.
   - Use chord recognition technique to analyze the audio for chord changes, store those in a structured format (e.g., list of tuples containing bar numbers and detected chords).

3. **Visualize Waveform and Chord Progressions**
   - Create a waveform visualization of the audio file alongside visual indicators for the detected chords at different sections of the track.

4. **MIDI File Analysis and Chord Suggestions**
   - When a MIDI file is uploaded, analyze its notes.
   - Implement a simple algorithm to match those notes with common chords (e.g., major/minor triads).
   - Suggest chord progressions based on the melody in the MIDI file.

5. **User Interface**
   - Create a clean UI to display the waveform, the detected chords, and suggestions in an easy-to-understand format.

### Example Implementation Approach (Python)

Below is a pseudocode outline using Flask with the libraries mentioned.

```python
from flask import Flask, request, jsonify
import librosa
import midi_processing  # custom module 
import chord_recognition  # custom module

app = Flask(__name__)

@app.route('/upload', methods=['POST'])
def upload_file():
    audio_file = request.files['audio']  # Upload WAV/MP3
    midi_file = request.files['midi']  # Upload MIDI

    # Process Audio File
    y, sr = librosa.load(audio_file, sr=None)
    tempo = librosa.beat.tempo(y=y, sr=sr)
    chords = chord_recognition.detect_chords(y, sr)  # This should return a list of (bar, chord)

    # Process MIDI File
    melody_notes = midi_processing.extract_notes(midi_file)

    # Suggest chord progressions based on melody
    suggested_progressions = midi_processing.suggest_chords(melody_notes)

    return jsonify({
        'tempo': tempo,
        'chords': chords,
        'suggested_progressions': suggested_progressions
    })

if __name__ == '__main__':
    app.run(debug=True)
```

### Considerations

1. **Data Quality**: Audio quality and complexity will affect the accuracy of chord detection.
2. **Performance**: Processing audio can be CPU-intensive, so consider using background processing for audio analysis.
3. **User Interface**: Ensure the UI is intuitive, especially for audio visualization and displaying results.

### Libraries You Might Explore

- **Audio Processing**: `Librosa`, `Sonic-API`
- **Chord Detection**: `Chordify`, `MIRtoolbox`
- **MIDI Processing**: `PrettyMIDI`, `Mido`
- **Web Framework**: `Flask`, `Django`
- **Frontend**: `React`, `Wavesurfer.js`

### Conclusion

While this project is ambitious and requires many facets of programming, music theory, and UI/UX design, following this structured approach will help you develop a functional application.