function Shapefile(){}

Shapefile.tNull=0;
Shapefile.tPoint=1;
Shapefile.tLine=3;
Shapefile.tPolygon=5;

Shapefile.create=function(shapeType){
	var m=new Shapefile();
	m.shapeType=shapeType;
	// Write file header:
	m.mf=new MemoryFile(100,true);
	m.mf.writeInt32(9994);	// file code
	m.mf.seek(24);m.mf.writeInt32(50);	// file lenght
	m.mf.setByteOrderBig(false);
	m.mf.writeInt32(1000);	// version
	m.mf.writeInt32(shapeType);	// shape type
	m.mf.setSize(100);
	m.extent=new KExtent();
	m.recordCount=-1;
	return m;
};
Shapefile.open=function(buffer){
	var m=new Shapefile();
	if(buffer instanceof MemoryFile){
		m.mf=buffer;
		m.mf.setByteOrderBig(true);
	}else
		m.mf=new MemoryFile(buffer,true);
	// Read file header:
	if(m.mf.readInt32()!=9994) throw "Not a shapefile";
	m.mf.seek(28);
	m.mf.setByteOrderBig(false);
	if(m.mf.readInt32()!=1000) throw "Unknown shapefile version";
	// TODO (shapefile.js) better exception for unsupported shape types!
	var type = m.mf.readInt32();
	switch(type){
		case 1:m.shapeType=Shapefile.tPoint;break;
		case 3:m.shapeType=Shapefile.tLine;break;
		case 5:m.shapeType=Shapefile.tPolygon;break;
		default:
			const types={0:"Null Shape",1:"Point",3:"PolyLine",5:"Polygon",8:"MultiPoint",11:"PointZ",13:"PolyLineZ",
				15:"PolygonZ",18:"MultiPointZ",21:"PointM",23:"PolyLineM",25:"PolygonM",28:"MultiPointM",31:"MultiPatch"};
			throw "Unsupported shape type "+types[type];
	}
	m.recordCount=-1;
	m.extent=new KExtent();
	if(m.mf.size>100){
		m.extent.xmin=m.mf.readFloat64();
		m.extent.ymin=m.mf.readFloat64();
		m.extent.xmax=m.mf.readFloat64();
		m.extent.ymax=m.mf.readFloat64();
	}
	m.mf.seek(100);
	return m;
};
Shapefile.prototype.eof=function(){
	return this.mf.eof();
};

Shapefile.prototype.get=function(){
	var m=this,shape=null,a,b,x,y;
	m.mf.skip(4);
	m.mf.setByteOrderBig(true);
	var length=m.mf.readInt32();
	if(length>0){
		var mf=new MemoryFile(m.mf.readRaw(length*2),false);
		var type=mf.readInt32();
		switch(type){
			case 0:
				shape=new KShape(KShape.stNull);
				break;
			case 1:
				x=mf.readFloat64();
				y=mf.readFloat64();
				shape=new KShape(KShape.stPoint);
				var line=new KLine();
				line.points.push(new KPoint(x,y));
				shape.lines.push(line);
				break;
			case 3:case 5:
				shape=new KShape(type==3?KShape.stLine:KShape.stPolygon);
				mf.skip(32);	// extent
				var numParts=mf.readInt32();
				var totalPoints=mf.readInt32();
				var parts=[];
				for(a=0;a<numParts;a++) parts.push(mf.readInt32());
				for(a=0;a<numParts;a++){
					var numPoints=a==numParts-1?totalPoints-parts[a]:parts[a+1]-parts[a];
					var line=new KLine();
					for(b=0;b<numPoints;b++){
						x=mf.readFloat64();
						y=mf.readFloat64();
						line.points.push(new KPoint(x,y));
					}
					shape.lines.push(line);
				}
				break;
		}
	}
	if(shape!=null) shape.precision=9;
	return shape;
};

Shapefile.prototype.add=function(shape){
	var ext=null,pt,a,b;
	var mf=new MemoryFile(4,false);
	if(shape.type==KShape.stNull || shape.lines.length==0){
		mf.writeInt32(0);
	}else if(shape.type==KShape.stPoint){
		if(this.shapeType!=Shapefile.tPoint) throw "Point shape not allowed";
		mf.writeInt32(1);
		pt=shape.lines[0].points[0];
		mf.writeFloat64(pt.x);
		mf.writeFloat64(pt.y);
	}else if(shape.type==KShape.stLine || shape.type==KShape.stPolygon){
		if(this.shapeType==Shapefile.tPoint) throw "Point shape allowed only";
		var parts=[],points=[];
		for(a=0;a<shape.lines.length;a++){
			parts.push(points.length);
			var pts=shape.lines[a].points;
			if(pts.length){
				for(b=0;b<pts.length;b++) points.push(pts[b]);
				if(this.shapeType==Shapefile.tPolygon && !pts[0].equals(pts[pts.length-1])) points.push(pts[0]);	// close polygon ring
			}
		}
		ext=shape.extent();
		mf.writeInt32(this.shapeType==Shapefile.tLine?3:5);
		mf.writeFloat64(ext.xmin);mf.writeFloat64(ext.ymin);mf.writeFloat64(ext.xmax);mf.writeFloat64(ext.ymax);
		mf.writeInt32(parts.length);
		mf.writeInt32(points.length);
		for(a=0;a<parts.length;a++) mf.writeInt32(parts[a]);
		for(a=0;a<points.length;a++){mf.writeFloat64(points[a].x);mf.writeFloat64(points[a].y);}
	}
	var length=mf.size/2;	// in 16bit words
	var m=this;
	if(m.recordCount==-1) m.detectCount();
	m.mf.setByteOrderBig(true);
	m.mf.seek(24);var shpPos=m.mf.readInt32();	// shpPos in 16bit words
	m.mf.seek(24);m.mf.writeInt32(shpPos+4+length);	// Update FileLength in file header
	// Write shape data
	m.mf.seek(shpPos*2);
	m.mf.writeInt32(++m.recordCount); // Record numbers start at 1
	m.mf.writeInt32(length);
	m.mf.write(mf.toArrayBuffer());
	if(this.extent.expand(ext)){	// Update BoundingBox
		m.mf.setByteOrderBig(false);
		m.mf.seek(36);
		m.mf.writeFloat64(this.extent.xmin);
		m.mf.writeFloat64(this.extent.ymin);
		m.mf.writeFloat64(this.extent.xmax);
		m.mf.writeFloat64(this.extent.ymax);
	}
};
Shapefile.prototype.detectCount=function(){
	this.recordCount=0;
	this.mf.seek(100);
	this.mf.setByteOrderBig(true);
	while(!this.mf.eof()){
		this.mf.skip(4);
		this.mf.skip(this.mf.readInt32()*2);
		this.recordCount++;
	}
};

Shapefile.prototype.toBlob=function(){
	return new Blob([this.mf.toArrayBuffer()]);
};
Shapefile.prototype.makeShx=function(){
	var shx=new MemoryFile(100,true);
	this.mf.seek(0);
	shx.write(this.mf.read(100));	// copy head
	this.mf.setByteOrderBig(true);
//var a=0;
	while(!this.mf.eof()){
		var pos=this.mf.tell();
		this.mf.skip(4);
		var size=this.mf.readInt32();
//console.log((++a)+" "+(size*2));
		this.mf.skip(size*2);
		shx.writeInt32(pos/2);
		shx.writeInt32(size);
	}
	shx.seek(24);shx.writeInt32(shx.size/2);	// Update FileLength in header
	return new Blob([shx.toArrayBuffer()]);
};