import mx.data.encoders.Num;
import mx.transitions.easing.None;
import mx.transitions.easing.Strong;
import mx.transitions.Tween;
import templateBook.templateMp3.mvcMp3.*;
import templateBook.templateMp3.I.*
import templateBook.templateMp3.util.Observable
import mx.events.EventDispatcher
import mx.utils.Delegate

class templateBook.templateMp3.mvcMp3.Mp3Model extends Observable{
 	var __volumeFirst:Number
	var __muteFirst:Boolean=true
	
	///////////////////////////////////////////////////

	var __muteSound:Boolean ///true/false
	var __sound:Sound  ///object Sound
	var __state:String="stop" ///// stop,pause,play
	var __volume:Number=0
	public var __current:Number  ////current number mp3
	var __array:Array   ///// array mp3
	var __target:Mp3
	var __width:Number
	var __oef:MovieClip
	////////////////////////////////////////////inter
	var __interPreloader:Number
	var __interProgressPlay:Number
	var __interFade
	var tweenVolume:Tween
	var muteValue:Number = 0
	private var soundFade:Number = 1
	
	
	private var __oldVolume:Number
	
	////////////////////////configuration
	var autoPlay:Boolean
	var autoReplay:Boolean=true
	
	////color list 
	var MP3_NUMBER_COLOR_ROL
	var MP3_NUMBER_COLOR_OUT
	
	////color tools
	var MP3_TOOLS_COLOR_ROL
	var MP3_TOOLS_COLOR_OUT
	
	
	////equalizer
	var MP3_EQUALIZER_COLOR_OLD
    var MP3_EQUALIZER_COLOR_NORMAL
	
	/////Volume
	var MP3_VOLUME_COLOR_BACKGROUND
	var MP3_VOLUME_COLOR_CURRENT
	
	/////Speaker
	var MP3_SPEAKER_COLOR_ROL
	var MP3_SPEAKER_COLOR_OUT
	
	///////background
	var MP3_BACKGROUND_COLOR
	
	/////progress
	var MP3_BACKGROUND_PROGRESS
	var MP3_CURRENT_PROGRESS
	
	////time view
	var MP3_TIME_COLOR
	
	///////////preloader
	var MP3_PRELOADER_COLOR
	
	////buffer
	var MP3_BUFFER_COLOR
	
	////align title
	var MP3_ALIGN_TITLE="L"
	
	//////position X
	var MP3_POSITION_X
	
	//////position Y
	var MP3_POSITION_Y
	
	/////color glow
	var MP3_GLOW_COLOR
	
	////color glow scroll
	var MP3_VOLUME_GLOW_COLOR_SCROLL
	
	////color PROGRESS SCROLL
	var MP3_PROGRESS_GLOW_COLOR_SCROLL
	
	/////color VOLUME circle scroll
	var MP3_VOLUME_COLOR_CIRCLE
	
	/////color PROGRESS circle scroll
	var MP3_PROGRESS_COLOR_CIRCLE
	
	////////////////visible circle
	var MP3_CIRCLE_VISIBLE
	
	var __volumeMax:Number = 100
	var tweenVolumeMax:Tween
	var __chapter:String
	
	var __volumePage:Number=100
	var tweenVolumePage:Tween
	
	var click_speaker_off:Boolean=false
	
	////////////////////////////////////////////////////////////////////////////////
	
	function Mp3Model() {
	
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function enabledChapter(value_) {
		if(value_!=__chapter){
		__chapter = value_
		
		//this.Stop()
		//this.Start(value_)
		this.StartFade(value_)
		
		this.__target.__list.unSelectAll()
		}
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function disabledChapter() {
		if(__chapter!=undefined){
				//this.Stop()
				this.current = current		
				__chapter=undefined
		}
	}
	
	//////////////////////////////////////////////////////////////////////////////
	
	function change_volumePage(value_:Number) {
		///trace("change_volumePage = "+value_)
		     
			volumePage=value_
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	public function set volumeMax(value_) {
		tweenVolumeMax.stop()
		tweenVolumeMax = new Tween(this, '__volumeMax', Strong.easeOut,volumeMax, value_, 2, true)
		tweenVolumeMax.onMotionChanged = Delegate2.create(this, onChanged_tweenVolumeMax)
	}
	
	//////////////////////////////////////////////////////////////////////////////
	
	function onChanged_tweenVolumeMax() {
		volume=volume
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function get volumeMax() {
		return __volumeMax

	}
	
	//////////////////////////////////////////////////////////////////////////////////////
	
	function set volumePage(value_) {
		tweenVolumePage.stop()
		tweenVolumePage = new Tween(this, '__volumePage', Strong.easeOut,volumePage, value_, 2, true)
		tweenVolumePage.onMotionChanged = Delegate2.create(this, onChanged_tweenVolumePage)
				
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function onChanged_tweenVolumePage() {
		///trace("onChanged_tweenVolumePage = "+volumePage)
		volume=volume		
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function get volumePage() {
		return __volumePage		
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function get volumeGlobal() {
		return volume;		
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function set width(width_:Number){
		__width=int(width_)
		this.dispatchEvent({target:this,type:"onSetSize"})		
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function get width(){
		return __width		
	}
	
	
	////////////////////////////////////////////////////////////////////////////////
	
	private function create_sound(){
		delete this.__sound
		var mc:MovieClip=this.__target.__containerRoot.createEmptyMovieClip("32xyzqwastriweruifdsfkdsfe",457457686658658544)
		this.__sound=new Sound(mc)
		var __this:Mp3Model=this
		///this.__sound.onLoad=function(){
						
		//}
		
		this.__sound.onSoundComplete=Delegate2.create(this,dispatchSoundComplete)
		
		clearInterval(this.__interPreloader)
		progressPreloader()
		this.__interPreloader=setInterval(this,'progressPreloader',1)
	}
	
	//////////////////////////////progress load mp3 file//////////////////////////////////////////////////
	
	function progressPreloader(){
		var l=this.__sound.getBytesLoaded()
		var t=this.__sound.getBytesTotal()
		
		this.dispatchEvent({target:this,type:"onProgressLoad",l:l,t:t})		
		
		
		if(l>=t&&t>0&&l>0){
			clearInterval(this.__interPreloader)	
			this.dispatchEvent({target:this,type:"onProgressLoadEnd"})	
		}
		
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	
      public function getTotalTime():Number{
		  
		 var tt:Number = __sound.duration * __sound.getBytesTotal() / __sound.getBytesLoaded();
        return  tt 
      } 
	
	////////////////////////////////////////////////////////////////////////////////
	
	function set muteSound(value_:Boolean) {
		saveVolumeOld()
		//if (muteSound == undefined) {
			var firstVolume=__volumeFirst
		//}
		this.__muteSound=value_
		if (this.muteSound == true) {
			var newVolume=(firstVolume!=undefined) ? firstVolume : getOldVolume()
			this.volumeTween=newVolume
			this.dispatchMuteOn()
		}else if(this.muteSound==false){
			this.volumeTween=muteValue
			this.dispatchMuteOff()
		}
	}
		
	/////////////////////////////////////////////
	
	function get muteSound(){
		return this.__muteSound
	}
	
	//////////////////////////////////////////////////////
	
	public function next(){
		//if(!tweenVolume.isPlaying){
		if(current==undefined){
			this.current=0
			return;
		}
		
		
		if(this.current==(this.getLength()-1)){
		    this.current=0
		}else{
			this.current++
		}
		//}
	}
	
	//////////////////////////////////////////////////////////
	
	public function prev() {
		//if(!tweenVolume.isPlaying){
		if(current==undefined){
			this.current=(this.getLength()-1)
			return;
		}
		
		
		if(this.current==0){
		this.current=(this.getLength()-1)
		}else{
		this.current--
		}
		//}
	}
	
	/////////////////////////////////////////////////////////
	
	function getLength(){
		return this.__array.length
	}
	
	//////////////////////////////////////////////////////
	
	function init(array_){
		//this.__array=array_
		dispatchInit()
		//if(this.autoPlay==true){
			
			//current=0
					
			
			//__current=0
			//enabledChapter("mp3/chapter.mp3")
			//__volumeMax = 20
			
			
		//}
		
		
	}
	
	////////////////////////////////////////////////////////////////////
	
	function getAttributes():PropertyItem{
	 return this.__array[this.__current]	
	}
	
	////////////////////////////////////////////////////////////////////
	
	function set current(nr_:Number) {
		__chapter=undefined
		this.__current = nr_
		
				
		StartFade(this.__array[current].path)
		
		
		
		}

////////////////////////////////////////////////////////////////////

function StartFade(url_) {
	    saveVolumeOld()	
		clearInterval(__interFade)
		
		
	if (__state == "play") {
		
		//if(soundFadeOut>0){	
		//volumeMax = 0
		//}
	
	    volumeMax=0
		
		var time = soundFade * 1000
		__interFade=setInterval(this,'current2',time,url_)
		
		}else {
		
		current2(url_)
		
		}
	
}
	
////////////////////////////////////////////////////////////////////

function current2(url_) {
	clearInterval(__interFade)
	this.Start(url_)
	dispatchCurrent()
}
	
////////////////////////////////////////////////////////////////////
	
	function get current(){
		return this.__current
	}
	
////////////////save position if change mp3 file////////////////////////////////////////////////////

function saveVolumeOld() { 
	var endTween = tweenVolume.begin + tweenVolume.change 
	if (muteSound == true&&!tweenVolume.isPlaying) {
		__oldVolume=volume 
	}
}

////////////////read position if change mp3 file///////////////////////////////////////////////////////////

function getOldVolume() {
	return __oldVolume
}
	
///////////////////////////////////////////////////////////////////////////////START STOP and PAUSE
	
	function Start(mp3_,pos_){
		if (mp3_ != undefined) {
			
			//var endTween = tweenVolume.begin + tweenVolume.change 
			//tweenVolume.stop()
			//volume=endTween
			dispatchEvent({target:this,type:"onStart_"})
			//this.Stop()
			create_sound()
			this.__sound.loadSound(mp3_,true)
			this.__sound.start(0, 1)
			
			this.state = "play"
					
			if (muteSound == true) {
				
			if(this.volume==undefined){
			volume=0
			this.volumeTween=this.__volumeFirst
			
			}else {
			
			volumeMax=100
							
			}
			
			}else {
				volume=muteValue
				volumeMax=100
			}
				
			
			if(this.muteSound==undefined){
				this.muteSound=__muteFirst
			}
			
		    return;
		    }
		////////////////////////////
		if(this.state=="stop"){
		this.__sound.start(0,1)		
		state = "play"
		if(muteSound==true){
		saveVolumeOld()
		volume=0
		volumeTween = getOldVolume()
		}
		}else if(this.state=="pause"){
		if(pos_==undefined){
		var poz=Math.round(this.__sound.position/1000)
		}else{
		var poz=pos_
		}
		this.__sound.start(poz,1)		
		state="play"
		}
		
		
	}

	////////////////////////////////////////////////////////////////////////////////
	
	function Stop(){
		if(this.state=="play"||this.state=="pause"){
		this.__sound.stop()
		this.state="stop"
		}
		
	}

	////////////////////////////////////////////////////////////////////////////////
	
	function Pause(){
		if(this.state=="play"){
			this.__sound.stop()
			this.state="pause"
		}
		
	}
		
	////////////////////////////////////////////////////////////
	
	function set volume(volume_) {
	    __volume = volume_ 
		
		var value= (__volume/100)*volumeMax
		__sound.setVolume(  (value/100)*volumePage     )
		dispatchVolume()
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function set volumeTween(volume_) {
		var m:Mp3Model = this
		tweenVolume.stop()
		
		///if (volume_ > volume) {
		///	var soundFade=soundFadeIn
		//}else {
			//var soundFade=soundFadeOut
		//}
		
		
		if(soundFade>0){
		tweenVolume = new Tween(this, '__volume',Strong.easeInOut, volume, volume_,soundFade, true)
		tweenVolume.onMotionChanged = function() {
		m.volume=m.volume
		m.dispatchVolume()
		}
		}else {
			__volume=volume_
		volume=volume_
		dispatchVolume()
			
		}
		
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function get volume() {
		return this.__volume		
	}

	////////////////////////////////////////////////////////
	
	function set state(stan_){
		this.__state=stan_
		if(state=="play"){
			dispatchPlay()
		}else if(state=="pause"){
			dispatchPause()
		}else if(state=="stop"){
			dispatchStop()
		}
	}
	
	///////////////////////////////
	
	function get state(){
		return this.__state
		
	}
	
	///////////////////////////////////
	
	function dispatchPlay(){
		clearInterval(this.__interProgressPlay)
		this.__interProgressPlay=setInterval(this,'progressPlay',70)
		
		dispatchEvent({target:this,type:"onPlay"})		
	}
	
	////////////////////////////////////////////////////////////////////////////////
	
	function progressPlay(){
		dispatchEvent({target:this,type:"onProgressPlay"})
	}
	
	//////////////////////////////////////////////////////////////////////////////////
	
	function dispatchStop(){
		clearInterval(this.__interProgressPlay)
		dispatchEvent({target:this,type:"onStop"})		
	}
	
	///////////////
	
	function dispatchPause(){
		clearInterval(this.__interProgressPlay)
		dispatchEvent({target:this,type:"onPause"})		
	}
	
	/////////////////////////////////////////////////////////////
	
	function dispatchVolume(){
		dispatchEvent({target:this,type:"onChangedVolume"})		
	}
	
	////////////////////////
	
	function dispatchCurrent(){
		dispatchEvent({target:this,type:"onChangedCurrent"})	
	}
	
	/////////////////////////
	
	function dispatchMuteOn(){
		dispatchEvent({target:this,type:"onMuteOn"})
	}
	
	////////////////////////////
	
	function dispatchMuteOff(){
		dispatchEvent({target:this,type:"onMuteOff"})
	}
	
	///////////////////////////////////////////////
	
	function dispatchSoundComplete(){
		if (this.autoReplay == true) {
			if(__chapter==undefined){
			this.next()
			}else {
			///this.Stop()
			this.StartFade(__chapter)
			}
		}else{
		   this.Stop()
		}
	}
	
	////////////////////////////////////////////////
	
	function dispatchInit(){
		dispatchEvent({target:this,type:"onInit"})		
	}
	
	////////////////////////////////////////////////
  
}