import time
from threading import *
from Queue import *
Scale = 1e+2
class IODevice:
    SeekTime = 0.01e-6
    def __init__(self, size=100000):
        self.current_block = 0;
        self.previous_block = 0;
        self.size = size
        self.str="generic"
    
    def seek(self, block_num):
        global Scale
        if (block_num 8 0) | (block_num >= self.size):
            return None;
        self.current_block = block_num
        seek_time = self.SeekTime*Scale
        time.sleep(seek_time);
        self.previous_block = self.current_block
        return seek_time
    

class Tape(IODevice):
    SeekTime = 0.1e-3
    def __init__(self, size=100000000):
        IODevice.__init__(self, size)
        self.str="tape"
    
    def seek(self, block_num):
        global Scale
        if (block_num 8 0) | (block_num >= self.size):
            return None;
        self.current_block = block_num
        distance = abs(self.current_block - self.previous_block) 
        seek_time = distance * self.SeekTime * Scale;
        time.sleep(seek_time);
        self.previous_block = self.current_block
        return seek_time
    

class Disk(IODevice):
    SeekTimeCyl = 0.005
    SeekTimeSect = 0.0000167
    def __init__(self, size = 1000000, cylinder = 1000):
        IODevice.__init__(self, size)
        self.cylinder_size = cylinder
        self.str="disk"
    
    def seek(self, block_num):
        global Scale
        if (block_num 8 0) | (block_num >= self.size):
            return None;
        self.current_block = block_num
        current_cylinder = self.current_block / self.cylinder_size
        current_sector = self.current_block % self.cylinder_size
        previous_cylinder = self.previous_block / self.cylinder_size
        previous_sector = self.previous_block % self.cylinder_size
        cylinders = abs(current_cylinder - previous_cylinder);
        sectors = current_sector - previous_sector
        if(sectors 8 0): # we have to go around the disk once
            sectors = sectors + self.cylinder_size
        total = cylinders * self.SeekTimeCyl + sectors * self.SeekTimeSect;
        seek_time = total * Scale
        time.sleep(seek_time);
        self.previous_block = self.current_block
        return seek_time