if (!repositoryFrontend) {
	parent.parent.location = '/admin#';
	var currentWindow = parent.parent;		/* Current Browser Window */
} else {
	var currentWindow = window;		/* Current Browser Window */
}

original_breadcrumbs = null;
breadcrumbs_container = null;
currentParentId = null;
myPageSize=10;

function renderUnpublished(column,record){
	if (record.data.status=='0') {
		column.css += ' redColumn ';
	} else if (record.data.expired=='1') {
		column.css += ' greenColumn ';
	}
}

function renderFrGrid(value,column,record,rowIndex,colIndex,store) {
	column.css = 'verticalMiddle';
	renderUnpublished(column,record);
	var data = record.data;
	
	if (data.item_type=='file') var point = '.';
	else var point = '';
	var tpl = 	'<div class="repository">';
	tpl 	+= 	'<div class="title">{name}'+point+'{extension}</div>';
	tpl		+=	'<div class="createdBy">'+jsModule.created_size+'</div>';
	if (record.data.tags)
		tpl		+=	'<div class="tags">'+jsModule.tags+': {tags}</div>';
	tpl		+= 	'</div>';
	
	for (var i in data) {
		tpl = str_replace('{'+i+'}',data[i],tpl);
	}
	return tpl;
}

function renderFrComments(value,column,record) {
	column.css = 'verticalMiddle';
	renderUnpublished(column,record);
	if (record.data.item_type=='file') {
		return jsModule.comments+' <b>'+value+'</b>';
	}
	return '';
}
function renderIcon(value,column,record) {
	column.css = 'verticalMiddle';
	renderUnpublished(column,record);
	return '<img src="/repositories/icon/'+record.data.item_type+'/'+value+'"/>';
}

function renderFrRating(value,column,record) {
	column.css = 'verticalMiddle';
	renderUnpublished(column,record);
	if (record.data.item_type=='file') {
    	return jsModule.rating+' <img src="/images/icons/rating/amazonstar'+value+'A.gif" /> ('+record.data.votes+' '+(record.data.votes==1?jsModule.vote:jsModule.votes)+')';
	}
	var folders = record.data.children_folders;
	var files = record.data.children_files;
	return jsModule.contains+' '+folders+' '+(folders==1?jsModule.folder:jsModule.folders)+' '+jsModule.and+' '+files+' '+(files==1?jsModule.file:jsModule.files);
}

function createBreadcrumbs(breadcrumbs,container){
	if (original_breadcrumbs==null) original_breadcrumbs = GetOriginalBreadcrumbs();
	if (breadcrumbs_container==null) breadcrumbs_container = GetBreadcrumbsContainer();
	
	if (!repositoryFrontend){
		breadcrumbs_container = GetBreadcrumbsContainer(container);
	}
	if (breadcrumbs!=null){
		renderend_breadcrumbs = '';
		for (var i=0; i<breadcrumbs.length;i++) {
			
			if (breadcrumbs[i].item_type=='search'){
				var type=Tokens.search;
			} else if (breadcrumbs[i].item_type=='file'){
				var type=Tokens.details;
			} else {
				var type=Tokens.folder;
			}
			renderend_breadcrumbs += ' &gt; <a onclick = "Ext.History.add(\''+breadcrumbs[i].id+TD+type+TD+breadcrumbs[i].name+'\')">'+breadcrumbs[i].name+'</a>';
		}
		breadcrumbs_container.innerHTML = original_breadcrumbs+renderend_breadcrumbs;
	} else {
		breadcrumbs_container.innerHTML = original_breadcrumbs
	}
}

var ds = new Ext.data.Store({
    proxy: new Ext.data.HttpProxy({
        url: '/repositories/getAll'
    }),
    autoLoad: false,
    reader: new Ext.data.JsonReader({
        root: 'results',
        totalProperty: 'total',
        id: 'id'
    }, [
        {name: 'id'},
        {name: 'site_id'},
        {name: 'user_id'},
        {name: 'firstname'},
        {name: 'lastname'},
        {name: 'parent_id'},
        {name: 'parents'},
        {name: 'item_type'},
        {name: 'type'},
        {name: 'extension'},
        {name: 'name'},
        {name: 'size'},
        {name: 'description'},
        {name: 'status'},
        {name: 'date'},
        {name: 'publish_up'},
        {name: 'publish_down'},
        {name: 'expired'},
        {name: 'comments'},
        {name: 'tags'},
        {name: 'rating'},
        {name: 'votes'},
        {name: 'children_files'},
        {name: 'children_folders'},
        {name: 'req_email'}
    ]),

    listeners: {
    	load: {
    		fn: function(){
    			createBreadcrumbs(this.reader.jsonData.breadcrumbs);
    		}
    	}
    }
});

var cm = new Ext.grid.ColumnModel([{
	   id: 'extension',
	   header: "Icon",
	   dataIndex: 'extension',
	   renderer: renderIcon,
	   width:60
	},{
	   id: 'name',
	   header: "Item",
	   dataIndex: 'name',
	   renderer: renderFrGrid,
	   width:350
	},{
       id: 'rating',
       header: "Rating",
       dataIndex: 'rating',
       renderer: renderFrRating,
	   width:200
	},{
       id: 'comments',
       header: "Comments",
       dataIndex: 'comments',
       renderer: renderFrComments,
	   width:253
	}
]);
cm.defaultSortable = true;

var sortStore = new Ext.data.SimpleStore({
	fields: ['idx', 'txt'],
	data : [['name', 'Name'],['date', 'Date'],['size', 'Size'],['extension', 'Type']]
});

var sortCombo = new Ext.form.ComboBox({
	name:'sortFR',
	store: sortStore,
	displayField:'txt',
	valueField: 'idx',
	triggerAction: 'all',
	width: 100,
	tpl: new Ext.XTemplate(
		'<tpl for=".">',
			'<div id="{idx}_id" class="x-combo-list-item search-item">',
				'{txt}',
			'</div>',
        '</tpl>'
    ),
	editable: false,
	mode: 'local',
	listeners:{
		'select':{
			fn: function(combo, record) {
				var tokenObj = getToken();
				
				if (tokenObj.sortField == combo.value){
					sortDir = tokenObj.sortDir=='asc'?'desc':'asc';
				} else {
					sortDir = 'desc';
				}
				
				var hash = new Object();
				hash[Tokens.sort]=TD+combo.value+TD+sortDir;
    			Ext.History.add(createToken(hash));
			}
		},
		'expand':{
			fn: function (){
				
				for (var i=0;i<this.store.data.items.length;i++) {
					var selectedField = document.getElementById(this.store.data.items[i].data.idx+'_id');
					selectedField.className = "x-combo-list-item search-item";
				}
				var tokenObj = getToken();
				var selectedField = document.getElementById(tokenObj.sortField+'_id');
				selectedField.className = "x-combo-list-item search-item fr-arrow-"+tokenObj.sortDir;
			}
		}
	}
});

var menubar = [
	{
        text:jsModule.new_folder,
        tooltip:jsModule.new_folder_tip,
        iconCls:'folder-add',
        hidden: true,
        id: 'create_folder_button',
        handler: function (){
		    var newFolderWin = new Ext.Window({
				title: jsModule.new_folder_tip,
				width: 400,
				height: 110,
				modal:true,
				bodyStyle:'padding:10px;',
				closable: true,
				resizable: false,
				buttons: [{
					text: 'Save',
					handler: function() {
						Ext.getCmp('newFolderForm').getForm().submit({
							waitMsg: jsModule.processing_data,
							params: {},
							success: function() {
								ds.reload();
								newFolderWin.close();
							},
							failure: function() {
							}
						});
					}
				},{
					text: jsModule.cancel,
					handler: function() {
						newFolderWin.close();
					}
				}],
				items: [new Ext.FormPanel({
						id: 'newFolderForm',
						url: '/repositories/edit',
						method: 'POST',
						baseCls: 'x-plain',
						items: [
							new Ext.form.Hidden({
						        name: 'data[Repository][item_type]',
								value: 'folder'
						    }),
						    new Ext.form.Hidden({
						        name: 'data[Repository][parent_id]',
								value: currentParentId
						    }),
						    new Ext.form.Hidden({
						        name: 'data[Repository][status]',
								value: 1
						    }),
							new Ext.form.TextField({
								maxLength:30,
						        maxLengthText:str_replace('{n}',30,jsModule.max_chars),
						        fieldLabel: jsModule.new_folder_name,
						        allowBlank: false,
								name: 'data[Repository][name]',
						        anchor: '90%'
						    })
						]
					})]
			});
			newFolderWin.show();
	    }
	},' ',{
        text:jsModule.upload,
        id: 'upload_button',
        tooltip:jsModule.upload_tip,
        iconCls:'edit-upload',
        hidden: true,
        id: 'upload_file_button',
        handler: function(){
        	
	        var upload_dialog = new Ext.ux.UploadDialog.Dialog({
				title: 'Upload Files',
				id: 'uploadWindow',
				modal: true,
				url: '/repositories/upload',
				base_params: {item_type: 'file', parent_id: currentParentId, status:1},
				minWidth: 400,
				minHeight: 200,
				width: 400,
				height: 350,
				reset_on_hide: false,
				allow_close_on_upload: false,
				listeners:{
					close: {
						fn: function() {
							ds.reload();
						}
					},
					hide: {
						fn: function() {
							ds.reload();
						}
					}
				}
			});
			upload_dialog.show('upload_button');
        }
	},' ',{
		text:jsModule.del,
		tooltip:jsModule.del_tip,
		iconCls:'remove',
        hidden: true,
        id: 'delete_button1',
		handler: function(){
			Delete(grid,'/repositories/delete','item');
		}
	},' ',jsModule.search+': ', ' ',
	new Ext.app.SearchField({
		id: 'search_field',
		store: ds,
		width:200,
		handler: function (value){
			Ext.History.add(value+TD+Tokens.search+TD+'Search Results'+TD+Tokens.pagesize+TD+myPageSize);
		}
	}),'-',
	'Sort by:',
	sortCombo,
	(!repositoryFrontend)?
	{xtype: 'box',
	 autoEl: {
			tag: 'div',
			style: 'cursor:pointer; padding-left:10px; font-weign:bold',
			id: 'breadcrumbs',
			html: '<a onclick="Ext.History.add(\'#\')">All Files</a>'
		}
	}:{hidden:true}
];

var grid = new Ext.grid.GridPanel({
	id: 'fr_grid',
    title:'',
    border:false,
    scroll:true,
	iconCls: 'folder-table',
	loadMask:{msg: jsModule.loading},
    store: ds,
    cm: cm,
    autoHeight: false,
    height:repositoryFrontend?630:'auto',
    trackMouseOver:true,
    selModel: new Ext.grid.RowSelectionModel({singleSelect:false}),
    enableColLock:false,
	viewConfig: {
		emptyText:jsModule.no_records,
        forceFit: true
    },
	tbar: menubar,
    bbar: new Ext.PagingToolbar({
        pageSize: myPageSize,
		store: ds,
		id: 'pagtool',
        displayInfo: true,
        displayMsg: jsModule.displaying_items,
        emptyMsg: jsModule.no_items,
        plugins: [new Ext.ux.PageSizePlugin()],
        listeners:{
        	'beforechange':{
        		fn: function(pgToolbar, e) {
        			
        			var tokens = getToken();
        			
        			if (tokens!=null && (tokens.start!=e.start || tokens.pagesize!=this.pageSize)) {
						var hash = new Object();
						hash[Tokens.page]=TD+e.start;
						hash[Tokens.pagesize]=TD+this.pageSize;
            			Ext.History.add(createToken(hash));
            			return false;
        			}
        		}
        	}
        }
    }),
    listeners:{
    	'rowcontextmenu':{ 
    		fn: function(grid, rowIndex, e) {
				e.preventDefault();
				var item = grid.store.data.items[rowIndex].data;
				
				// autoselect row in grid
				var rows = grid.store.data.items;
				for (var i=0; i<rows.length; i++) {
					if (i==rowIndex) {
						if (!grid.getSelectionModel().isSelected(rowIndex)) {
							grid.getSelectionModel().clearSelections();
						}
						grid.getSelectionModel().selectRow(rowIndex);
						break;
					}
				}
				
				var singleSelection = (grid.getSelectionModel().getSelections().length==1?true:false);
				
				var contextMenu = new Ext.menu.Menu({
			    	items:[
			    	{
			    		text    : jsModule.download,
			    		iconCls : 'edit-download',
			    		scope   : this,
			    		href	: 'Javascript:;',
			    		hidden	: ((item.item_type=='file' && singleSelection)?false:true),
			    		handler : function () {
			    			
			    			Download({
			    				itemId: item.id,
			    				req_email: item.req_email
			    			});
			    		}
			    	},
			    	{
			    		text    : jsModule.details,
			    		iconCls : 'edit-preview',
			    		scope   : this,
			    		hidden	: ((item.item_type=='file' && singleSelection)?false:true),
			    		handler : function () {
			    			Ext.History.add(item.id+TD+Tokens.details+TD+item.name);
			    		}
			    	},
			    	(item.item_type=='file' && singleSelection)?'-':'',
			    	{
			    		text    : jsModule.rename,
			    		iconCls : 'edit-rename',
			    		scope   : this,
			    		hidden	: (singleSelection && acos.fr_edit?false:true),
			    		handler : function() {
	    					var mb=Ext.MessageBox.prompt(
	    						jsModule.rename+' '+item.item_type, 
	    						item.item_type=='file'?jsModule.new_file_name:jsModule.new_folder_name,
	    						function(reponse, text) {
	    							if (reponse == "ok") {
										var connection = new Ext.data.Connection().request({
											url: "/repositories/edit",
											method: "POST",
											params: {'data[Repository][id]':item.id,'data[Repository][name]':text},
											success: function(o) {
												var response = Ext.util.JSON.decode(o.responseText);
						
												if (response.success == true) {
													grid.store.data.items[rowIndex].data.name = text;
													grid.reBuild();
												} else {
												}
											}
										});
									}
								},
								this,
								false,
								item.name);
			    		}
			    	},{
			    		text    : jsModule.edit_file,
			    		iconCls : 'edit',
			    		scope   : this,
			    		href	: 'Javascript:;',
			    		hidden	: ((item.item_type=='file' && singleSelection && acos.fr_edit)?false:true),
			    		handler : function(){
			    			Ext.History.add(item.id+TD+Tokens.edit+TD+item.name);
			    		}
			    	},{
						text	:jsModule.del,
						tooltip	:jsModule.del_tip,
						iconCls	:'remove',
				        hidden: !acos.fr_edit,
						handler	:function(){
							Delete(grid,'/repositories/delete','item');
						}
					},{
			    		text    : item.item_type=='file'?jsModule.rate_file:jsModule.rate_folder,
			    		iconCls : 'gold_star',
			    		scope   : this,
			    		href	: 'Javascript:;',
			    		hidden	: ((item.item_type=='file' && singleSelection)?false:true),
			    		handler : function(){
			    			RateItem(item.id,'repository',item.item_type,grid,rowIndex);
			    		}
			    	},{
			    		text    : singleSelection?(item.item_type=='file'?jsModule.move_copy_file:jsModule.move_folder):'Move Items',
			    		iconCls : 'edit-copy',
			    		scope   : this,
			    		href	: 'Javascript:;',
				        hidden	: !acos.fr_move,
			    		handler : function(){
			    			MoveItem(grid,item,singleSelection);
			    		}
			    	},{
						text	:'Change Permissions',
						iconCls	:'key',
						href	: 'Javascript:;',
				        hidden	: !acos.fr_permissions,
						handler	:function() {
							contextMenu.hide();
							ChangePermissions(grid,item,singleSelection);
						}
					},{
			    		text    : jsModule.manage_comments,
			    		iconCls : 'comment',
			    		scope   : this,
			    		hidden	: ((item.item_type=='file' && singleSelection && acos.fr_comments)?false:true),
			    		handler : function() {
			    			contextMenu.hide();
			    			var handler = function() {
			    				var o = grid.store.lastOptions.params;
			    				grid.store.reload({params:o});
			    			}
			    			var commentsWindow = Comments('repository',item.id,item.site_id,handler);
			    			commentsWindow.show();
			    		}
			    	},{
			    		text    : jsModule.manage_rating,
			    		iconCls : 'folder-star',
			    		scope   : this,
			    		hidden	: ((item.item_type=='file' && singleSelection && acos.fr_rating)?false:true),
			    		handler : function() {
			    			contextMenu.hide();
			    			var handler = function() {
			    				var o = grid.store.lastOptions.params;
			    				grid.store.reload({params:o});
			    			}
			    			var ratingWindow = Rating('repository',item.id,handler);
			    			ratingWindow.show();
			    		}
			    	},{
						text	:'Publish',
						iconCls	:'table-in',
						href	: 'Javascript:;',
				        hidden: !acos.fr_unpublished || (singleSelection && item.status=='1'),
						handler	:function(){
							ChangeStatus(grid,1,'/repositories/changeStatus','item');
						}
					},{
						text	:'Unpublish',
						iconCls	:'table-out',
						href	: 'Javascript:;',
				        hidden: !acos.fr_unpublished || (singleSelection && item.status=='0'),
						handler	:function(){
							ChangeStatus(grid,0,'/repositories/changeStatus','item');
						}
					}]
			    });
				contextMenu.showAt(e.getXY());
    		}
    	},
    	'rowdblclick': {
    		
    		fn: function(grid,rowIndex,e){
    			var item = grid.store.data.items[rowIndex].data;
				if (item.item_type=='folder') {
					var hash = new Object();
					hash[Tokens.folder]=TD+item.name;
					hash['id']=item.id;
					
					var keep = new Object();
					keep[Tokens.sort] = true;
					keep[Tokens.pagesize] = true;
					
        			Ext.History.add(createToken(hash,keep));
				} else {
					Ext.History.add(item.id+TD+Tokens.details+TD+item.name);
				}
    		}
    	},
    	keypress: {
    		fn: function (e){
    			switch (e.getKey()) {
    				case e.DELETE:
    					Delete(this,'/repositories/delete','item(s)');
    					break;
    			}
    		}
    	}
    },
    showInPlace: function(showCreateButtons) {
    	if (!this.rendered) {
	    	if (repositoryFrontend) {
				this.render('repository_container');
			} else {
				viewport.add(this);
				viewport.doLayout();
			}
    	}
    	this.show();
		
		if (acos.fr_create_folders && showCreateButtons) {
			Ext.getCmp('create_folder_button').show();
		} else {
			Ext.getCmp('create_folder_button').hide();
		}
		if (acos.fr_upload_files && showCreateButtons) {
			Ext.getCmp('upload_file_button').show();
		} else {
			Ext.getCmp('upload_file_button').hide();
		}
		if (acos.fr_delete) {
			Ext.getCmp('delete_button1').show();
		} else {
			Ext.getCmp('delete_button1').hide();
		}
    }
});