import java.net.*;
import java.io.*;
import java.net.URL.*;
import java.util.*;
import java.lang.Comparable.*;
public class URLabi {

/*
 * String refref(String link)
 * URL urliks(String urlsone)
 * String http_html(URL u)
 * String[] sorteeri(String[] sisend)
 * String[] kontrurl(String[] ur)
 * SortedSet sortsort(String[] sisend, SortedSet s)
 * String[] lingid*String sisu(
 * String absoluutseks(String, kontekst, String viide(
 * String[] absoluutseteks(String kontekst, String viited[])
 * String URLsisu(String url)
 * String[] URLlingid(String url)
 * boolean kopeeri(String url, String failinimi)
 * boolean kopeeri(String url, String urlalus, String algkataloog)
    kokku 13
*/

public static String refref(String link) {
try{

if (link.indexOf("#")>=0){
if (link.startsWith("#"))
return null;
else{
StringTokenizer st = new StringTokenizer(link, "#");

return st.nextToken();
}
} else return link;
}catch (Exception v){
return link;
 }
}

public static URL urliks(String urlsone) throws MalformedURLException {
	try{
 	URL u=new URL(urlsone);
return u;
	} catch (MalformedURLException  pole_url)
	 {
return new URL(null);
}

}

// eraldab urlist viite faili kohale
public static String http_html(URL url){
String ref=url.getRef();
int liiast=ref.length();
String strurl=url.toString();
String vastus=strurl.substring(0, strurl.length() - liiast);
return vastus;
 }

// kontrollib sisestatud masiivi, korduvatale elementidele
  public static String[] sorteeri(String[] sisend) {

if (sisend.length==(0))  {
 String[] vastus=null;
return vastus;
} // kui sisestati tyhi masiiv kinni

// automaatselt sorteeruv hulk
	SortedSet sr = new TreeSet();

  boolean korras;
// sisestatakse elemendid hulka voib olla sobimatuid elemente
  for (int nr=0; nr<sisend.length; nr++)
try{
 korras=sr.add((Object)sisend[nr]);
}catch (IllegalArgumentException sobimatu) 	{}
// uuesti hulgast katte
	Object[] obj=sr.toArray();
	String[] vastus= new String[obj.length];
// tulemuseks saadava masiivi va"a"rtustamine
 for (int nr=0; nr<obj.length; nr++)
 vastus[nr]=obj[nr].toString();

  return vastus;
 } // end sorteeri

// otsib sonest html linke
// pole kasutatud SortedSet i, kuna samasse kohta voivad olla
// suhtelisi ja absoluutseid linke
// ei saa katte linkide arvu, kui peaks olema soovi. 
public static SortedSet sortsort(String[] sisend, SortedSet s) throws Exception{
for (int nr=0; nr<sisend.length; nr++) {
try{
s.add(sisend[nr]);
 } catch (IllegalArgumentException sobimatu) {}
 //  } catch (IllegalArgumentException sobimatu) {}
}
return s;
}

public static String[] kontrurl(String[] sisend)  throws IOException{
Vector v= new Vector();

for (int nr=0; nr<sisend.length; nr++) {
v.addElement(urliks(sisend[nr]).toString());;
 } // end for
Hd hd1 = new Hd();
return hd1.stringideks(v);
}


// pole kasutatud SortedSet i, kuna samasse kohta voib alla
// nii suhtelisi kui absoluutseid viiteid ka linkide arv laheb kaotsi kui vaja
 public static String[] lingid(String sisu) throws IOException{
 Vector v = new Vector();

// tykeldatakse <> margi jargi html koodi ta"hised tykid kaasa?
    StringTokenizer st1=new StringTokenizer(sisu, "<>", true);
    while(st1.hasMoreTokens()){
// kui html kood algab kood eraldada
      if((st1.nextToken().equals("<"))&st1.hasMoreTokens()){ //3 algus
        String juhtrida=st1.nextToken();

// eraldatakse uus tykeldaja. eraldajateks on =, tyhik, jutuma"rk,
// reavahetus ja veel midagi \t
        StringTokenizer tag=new StringTokenizer(juhtrida, " \n\t=\"");
        while(tag.hasMoreTokens()){
// leitakse link href on tema ta"his
          if(tag.nextToken().toLowerCase().equals("href")&
                                       tag.hasMoreTokens()){
            String link=tag.nextToken();
// lAheb masiivi

if (!link.startsWith("#"))
            v.addElement(link);
          }
        }
      } // 3 oma
    } // koik tsyklid otsas
    String[] tulemus=new String[v.size()]; 

// vaartustatakse edaspidi valjastatav Stringimasiiv
    for(int i=0; i<v.size(); i++){
// if (!((String)v.elementAt(i)).equals("0"))
tulemus[i]=refref(((String)v.elementAt(i)));
}
// saadakse masiiv tekstist leitud linkidest sorteerimata
    return tulemus;
 } // lingid ots

  public static String absoluutseks(String kontekst, String viide)
  throws IOException
  {
// kui viites ei ole symboleid koolon langjoon langoon
    if(viide.indexOf("://")<0)
// kui viide on suhteline, siis URL class lubab teha selle absoluutseks
// valjastada Stringina?
      return(new URL(new URL(kontekst), viide)).toString();
    else return viide;
  }

// laheb ilmselt sisse meetod lingid saadud masiiv
  public static String[] absoluutseteks(String kontekst, String viited[])
  throws IOException{
    String tulemus[]=new String[viited.length];
    for(int i=0; i<viited.length; i++)
// siin lihtsalt kasutatakse eelmist meetodit hulgi masiivijaoks
      tulemus[i]=absoluutseks(kontekst, viited[i]);
    return tulemus;
  }

// urlilt lugemine saadakse pikk string ette antakse aadress
  public static String URLsisu(String url) throws IOException{
    BufferedReader sisse=new BufferedReader(
      new InputStreamReader(
        new URL(url).openConnection().getInputStream()
      )
    );
// stringibuffer hoidmiseks
    StringBuffer tulemus=new StringBuffer();
    String rida=sisse.readLine();
// koik korraga
    while(rida!=null){
      tulemus.append(rida+"\n");
      rida=sisse.readLine();
    }
// ongi koik kaes anna katte
    return new String(tulemus);
  }

//  antakse ette url
  public static String[] URLlingid(String url){
    boolean korras=true;
// on korras ja tyhi Stringimasiiv
    String[] absoluutlingid=null;
    try{
       String sisu=URLsisu(url);
// siin olevate meetoditega voetakse urli sisu ja eraldatakse lingid
       String lingid[]=lingid(sisu);
       // URL lubab suhtelis aadressi teha absoluutseks . siin on see metodis apsoluutseks
       absoluutlingid=absoluutseteks(url, lingid);

    }catch(IOException e){
      korras=false;
    }
// kui on mingi viga, siis tehakse masiiv tyhjaks
    if(!korras) absoluutlingid=new String[0];
    return absoluutlingid;
  }

// salvestab ettentud URLilt ette antud faili ja teatab, 
// kuidas URLilt lugemine ja salvestaminelaks korras mitte_korras
  public static boolean kopeeri(String url, String failinimi){
    boolean korras=true;
    try{
      InputStream in=new URL(url).openConnection().getInputStream();
      OutputStream out=new FileOutputStream(failinimi);
//      int hulk=0;
      int nr=in.read();
// loetakse esimene rida ja jatkatakse kuni pole saabunud negatiivset arvu -1
      while(nr>=0){
        out.write(nr);
        nr=in.read();
//        hulk++;
//        if((hulk%1000)==0)System.out.print(hulk/1000+" ");
      }
      in.close();
      out.close();
// kui oli viga printStackTrace=veateade
    }catch(Exception e){korras=false; e.printStackTrace();}
    return korras;
  }

// see meetod on samanimeline kui eelmine, kui 
// talle antakse sisendina teised argumendid
  public static boolean kopeeri(String url, String urlalus, String algkataloog){
// url antakse aadress kust soovitakse kopeeridaja kui, (ma arvan leitud link) 
// urlalus viitab mujale, siis lopeta ja teata ebaonnestumisest
// kui urlalus ei alga url -ga
    if(!url.startsWith(urlalus))return false;
// saadakse salvestatava faili nimi, 
// et nad oleksid erikataloogides kuidas tapselt?
// failinimes on ette antud kataloog (algkataloog) failieraldaja
// ja osasone (substring) urlalus /st , kus on / asendatud 
// universaalse? failieraldajaga. Kuhu saab http://www...?
    String failinimi=algkataloog+File.separator+url.substring(urlalus.length()).
       replace('/', File.separatorChar);
// kui "failinimi" lopeb failieraldajaga, siis 
// anna failile nimeks index.html
    if(failinimi.endsWith(File.separator))failinimi+="index.html";
// saadakse kataloog, kuhu panna vottes osasone"failinimi" 
// algusest kuni viimase failieraldaja esinemiskohani
    String kataloog=failinimi.substring(0, failinimi.lastIndexOf(File.separator));
// tehakse vastav kataloog
    new File(kataloog).mkdirs();
// kopeerib eelmise meetodi abil sellesse kataloogi URLilt faili
// tema originaalnimega
    return kopeeri(url, failinimi);
  }
} // rohkem pole